home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / Libraries / DCLAP 6d / dclap6d / DBio.more / old / USeqApp-aln.cp < prev    next >
Text File  |  1996-07-05  |  83KB  |  3,173 lines
  1. // USeqApp.aln.p -- alignment window/views 
  2. // d.g.gilbert, 1991 
  3.  
  4. /*
  5.         fix AlnPasteCommand so we don't cause bombs w/ paste + use of
  6.         uncommitted seqs (dispose?)
  7. */
  8.  
  9.  
  10. CONST
  11.     kAlnDocID == kAlnWindID;
  12.     kMinCommonPercent == 0.80;  //need user opt 
  13.  
  14.     kModifiedFlag == False; // temp until we figure out proper conditions for fSeq.modified 
  15.  
  16. VAR
  17.     integer        gMinCommonPercent; //??
  18.     TextStyle        gAlnTextStyle ;
  19.     longint        gMaxViewCellsBugFix;
  20.     Boolean        gMaxViewCellsBugSeen;
  21.     
  22. // TAlnSequence ------------------------
  23.  
  24. /*DEBUG AlnSeq edit display... 
  25.  
  26.     !problem of jumping up to vert=0 line seems to be color-related,
  27.     !problem of cursor/display frozen at horizontal=1 is related to long seqs > 1000...3000
  28. */
  29.  
  30. #pragma segment AOpen
  31. pascal void TAlnSequence::IAlnSequence(TSequence aSeq)
  32. VAR    aTextData: TTextData;
  33. {
  34.     fSeq= aSeq;
  35.     fFreeText= FALSE;   
  36.   fInset= gZeroVRect;   
  37.  
  38.     New(aTextData); 
  39.     FailNIL( aTextData);
  40.     aTextData->ITextData();
  41.     if ((aSeq!=NULL)) {
  42.         Handle(aTextData->fChars)= DisposeIfHandle(aTextData->fChars);
  43.         aTextData->fChars= aSeq->fBases;
  44.         }
  45.     fTextData= aTextData;
  46.     fSearchData.hTarget= NULL;
  47. }
  48.  
  49. pascal void TAlnSequence::ReplaceSeq(TSequence aSeq)
  50. {
  51.     fSeq= aSeq;
  52.     if ((fSeq!=NULL)) {
  53.         fTextData->fChars= fSeq->fBases;
  54.         StuffText( fSeq->fBases);
  55.         }
  56. }
  57.  
  58. #pragma segment AClose
  59. pascal void TAlnSequence::Free(void) // override 
  60. {
  61.     fTextData->fChars= NULL;
  62.     fTextData->Free();
  63.     fTextData= NULL;
  64.     fFreeText= FALSE;  
  65.     if ((fSearchData.hTarget!=NULL)) {
  66.         DisposHandle(Handle(fSearchData.hTarget));
  67.         fSearchData.hTarget= NULL;
  68.         }
  69.         
  70.     inherited::Free();       
  71. }
  72.  
  73.  
  74. pascal void TAlnSequence::DeInstall(void) 
  75. //unlink fSeq: TSequence from TTextView stuff
  76. //! must unlink seq from EditSeq or will dispose seq in next*2 install
  77. {
  78.     //- InstallSelection(TRUE, FALSE); -- not in Mapp3 ?! Need alternate?
  79.     fSeq= NULL;
  80.     fTextData->fChars= NULL;
  81.     StuffText(fSavedTEHandle);  
  82.     // ^^^^ this prevents sequences from Being Trashed !!!
  83. }
  84.  
  85.  
  86.  
  87.  
  88. #pragma segment ARes
  89. pascal void alnTEDrawHook(void)
  90. VAR
  91.     integer        indx, len; //must be, for regs?
  92.     integer        endx, i ;
  93.     char        ch, lastch;
  94.     CharsPtr        pText;
  95.  
  96.     longint        cw, pend, skip;
  97.     grafPtr        aPort;
  98.     pt    : point;
  99.     
  100.     procedure pushregs; inline 0x48E7,$FFF8;//movem.l d0-d7/a0-a4,-(sp)
  101.     procedure popregs;    inline 0x4CDF,$1FFF;//movem.l (sp)+,d0-d7/a0-a4
  102.     procedure getD0D1A0( integer var d0, d1, CharsPtr var a0) inline
  103.         0x225F,    //move.l  (a7)+, a1
  104.         0x2288,    /*move.l    a0, (a1)*/         
  105.         0x225F,    //move.l  (a7)+, a1
  106.         0x3281,    /*move.w    d1, (a1)*/       
  107.         0x225F,    //move.l  (a7)+, a1
  108.         0x3280();    /*move.w    d0, (a1)*/         
  109.  
  110.     //-- test if rgbcolor is time dragger.. only Partly...
  111.     /*! looks like Indx == LineStart and Len == lineLen even
  112.          when only a small portion of line is drawn !
  113.          -- try calc TRUE indx for visible text
  114.          from destrect-viewrect ???
  115.         ---*/
  116. {
  117.     pushregs(); //-- ? not needed
  118.     getD0D1A0( indx, len, pText);
  119.     
  120.     //this helps!
  121.     cw= gAlnCharWidth;
  122.     getpen( pt);
  123.     if pt.h < 0 then {
  124.         skip= (-pt.h) / cw;
  125.       indx= indx + skip;
  126.         len= len - skip;
  127.         move( skip*cw, 0);
  128.         }
  129.         
  130.     pend= len * cw; //<<! integer overflow w/ len ~> 3000 ??
  131.     GetPort(aPort);
  132.     if pend > aPort->portRect.right then {
  133.         skip= (pend - aPort->portRect.right) / cw;
  134.         len= len - skip;
  135.         }
  136.             
  137.     endx= indx + len - 1;
  138.     lastch= ((char)(0));
  139.     for indx= indx to endx do {
  140.         ch= (*pText)[indx];
  141.         if (ch!=lastch) then
  142.          case ch of
  143.             'A','a': RGBForeColor( gAcolor);
  144.             'C','c': RGBForeColor( gCcolor);
  145.             'G','g': RGBForeColor( gGcolor);
  146.             'T','t',
  147.             'U','u': RGBForeColor( gTcolor);
  148.             otherwise
  149.                              RGBForeColor( gNcolor);
  150.             }
  151.      DrawChar(ch);
  152.      lastch= ch;
  153.     //_ if (indx mod 10 == 9) then DrawChar(' '); *//*spacer ??
  154.      }
  155.      
  156.     popregs();
  157. } //alnTEDrawHook
  158.  
  159.  
  160.  
  161. pascal void TAlnSequence::MakeTERecord(void) // override 
  162. VAR  
  163.     procPtr        mydraw, mydrawstripped, addr;
  164. {
  165.     inherited::MakeTERecord();
  166.     
  167.     mydraw= &alnTEDrawHook;  // debug this, are we getting right address here !?
  168.     mydrawstripped= procPtr(StripLong(mydraw));
  169.     addr= mydrawstripped;
  170.  
  171.     //- TECustomHook(intDrawHook, addr, fHTE);
  172.     gDefTEDrawHook= addr;     //save default
  173.  
  174.     //!? is alnTEDrawHook bad in mapp3 YES YEYEYEYEYEYEGGEYEGEGEGEG?!?!>?!?!?!?!?>?!
  175.  /*     if (True) { */
  176.   if (!gConfiguration.hasColorQD) {   
  177.         addr= gDefTEDrawHook;
  178.         //- TECustomHook( intDrawHook, addr, fHTE); 
  179.         }
  180. }
  181.  
  182.  
  183. #pragma segment AOpen
  184. pascal void TAlnSequence::ShowReverted(void) /* override */ 
  185. {
  186.     inherited::ShowReverted();
  187. }
  188.         
  189.         
  190. pascal TAlnSequence::HandleMouseDown( VPoint theMouse, TToolboxEvent event, 
  191.                              hysteresis: Point):Boolean; // override 
  192. VAR  theTarget: TView; //?
  193. {        
  194.     theTarget= TView(GetWindow->fTarget); 
  195.     if (theTarget != this) if (BecomeTarget); //GetWindow->SetTarget(this); 
  196.   HandleMouseDown= inherited::HandleMouseDown(theMouse,event,hysteresis);
  197. }
  198.         
  199.     
  200. pascal void TAlnSequence::DoKeyEvent( TToolboxEvent event) // override 
  201. /*! Intercept upArrow, downArrow, return, enter, tab keys:
  202.     up/downarrow -> move this up/down in alnView
  203.     return -> move this down (& to left margin?) in alnView
  204.     enter  -> ?
  205.     tab    -> ?
  206.     chClear chDown chEnd    chHome chEnter chEscape
  207.     chHelp chLeft chPageDown chPageUp
  208.     chReturn chRight chTab chUp
  209.     --------*/
  210. CONST
  211.     down1     ==  1;
  212.     up1            == -1;
  213.     downPage     ==  10;  // this is arbitrary...
  214.     upPage        == -10;
  215.     toBottom=  25000;
  216.     toTop        == -25000;
  217.     
  218.     procedure vertMove(integer nrows) // +/- nrows
  219.     integer        var  aRow, aCol;
  220.     {
  221.         aRow= MinMax( 1, TAlnView(fSuperView).fEditRow + nrows, 
  222.                                             TAlnView(fSuperView).fNumOfRows);
  223.         aCol= (*fHTE)->selStart;
  224.         TAlnView(fSuperView)->InstallEditSeq(aRow, aCol, aCol, kHighlight);
  225.     }
  226.         
  227. {
  228.     if (Focus) ; //? fix for misplaced drawing when typing ???
  229.     
  230.     CASE event->fCharacter OF
  231.         /*----
  232.         case chEscape:
  233.             if (event->fKeycode == kClearVirtualCode) ...
  234.             else ...;
  235.         -----*/
  236.         
  237.         chTab: ;
  238.           //? do horizontal shift here ?
  239.             /*---
  240.             if event.IsShiftKeyPressed then vertMove(up1)
  241.             else vertMove(down1);
  242.             -----*/
  243.             
  244.         case chRight:
  245.             if event.IsShiftKeyPressed then 
  246.             else inherited::DoKeyEvent(event);
  247.         case chLeft:
  248.             if event.IsShiftKeyPressed then 
  249.             else inherited::DoKeyEvent(event);
  250.             
  251.         case chUp:
  252.             if event.IsShiftKeyPressed then vertMove(toTop)
  253.             else vertMove(up1);
  254.             
  255.         chDown,
  256.         chEnter, chReturn:
  257.             if event.IsShiftKeyPressed then vertMove(toBottom)
  258.             else vertMove(down1);
  259.             
  260.         chPageDown    :    vertMove( downPage); 
  261.         chPageUp        :    vertMove( upPage);
  262.         chHome            : vertMove( toTop);
  263.         chEnd                 : vertMove( toBottom);
  264.             
  265.         default: 
  266.             inherited::DoKeyEvent(event);
  267.             
  268.         }
  269.     
  270.     if (( kModifiedFlag /*???? aCommand != gNoChanges*/) && (fSeq!=NULL) then begin
  271.         fSeq.modified; 
  272.         }
  273. }
  274.  
  275. pascal void TAlnSequence::DoMenuCommand(aCommandNumber:CommandNumber); // override 
  276. {
  277.     inherited::DoMenuCommand(aCommandNumber);
  278.     if ( kModifiedFlag /*????aCommand != gNoChanges*/) && (fSeq!=NULL) then begin
  279.         fSeq.modified; 
  280.         end();
  281. }
  282.  
  283. pascal void TAlnSequence::DoMouseCommand(VPoint VAR theMouse, TToolboxEvent event,
  284.                                                Point hysteresis) // override 
  285. {
  286.     inherited::DoMouseCommand(theMouse,event,hysteresis);
  287.     if ( kModifiedFlag /*????aCommand != gNoChanges*/) && (fSeq!=NULL) then begin
  288.         fSeq.modified; 
  289.         end();
  290. }
  291.  
  292. pascal TTETypingCommand TAlnSequence::DoMakeTypingCommand(Char ch) // override 
  293. VAR  aAlnseqTypingCommand:     TAlnseqTypingCommand;
  294. {
  295.     if (Focus) ; //? fix for misplaced drawing when typing ???
  296.     New(aAlnseqTypingCommand);
  297.     FailNIL(aAlnseqTypingCommand);
  298.     aAlnseqTypingCommand->ITETypingCommand(this, ch);
  299.     DoMakeTypingCommand = aAlnseqTypingCommand;
  300. }
  301.  
  302. pascal void TAlnseqTypingCommand::DoNormalChar( Char aChar) // override 
  303. VAR  aSeq: TSequence;
  304.         TAlnView        aAlnView;
  305. {
  306.     inherited::DoNormalChar( aChar);
  307.     aAlnView= TAlnView(TAlnSequence(fTEView).fSuperView);
  308.     aSeq= TAlnSequence(fTEView).fSeq;
  309.     aAlnView->UpdateWidth(aSeq);
  310.     if (TAlnSequence(fTEView).Focus) ; //? fix for misplaced drawing when typing ???
  311.  
  312.         //? fix for integer overflow.... 
  313.     /*---  no good...
  314.     WITH TAlnSequence(fTEView).(*fHTE)^){
  315.         if ((destRect.right < 0)) destRect.right= 20000;
  316.         if ((viewRect.right < 0)) viewRect.right= 20000;
  317.         }
  318.     ----*/
  319. }
  320.  
  321.  
  322.  
  323.  
  324.  
  325. // TAlnView ------------------------
  326.  
  327.                 
  328. #pragma segment TAlnView
  329.     
  330.     
  331. pascal void TAlnView::IAlnView( TAlnDoc itsDocument, TSeqList aSeqList)
  332. VAR  
  333.         VRect        vbounds;
  334. {
  335.     fAlnDoc= itsDocument;
  336.     fAlnList= aSeqList;
  337.     fLocked= FALSE;
  338.     
  339.     DelColLast( fNumOfCols);   //fix for prefsave...
  340.     fRowheight= GetRowHeight(1);
  341.     DelRowLast( fNumOfRows);  
  342.     RowToVRect( 1, 1, vbounds); 
  343.     gAlnTextStyle= gAlnStyle; //temp
  344.     fEditSeq= NULL;
  345.     
  346.     fEditSeq = TAlnSequence(
  347.                     gViewServer->DoCreateViews(fDocument, this, kAlnTEViewID, vbounds.topleft));
  348.     FailNIL(fEditSeq);
  349.     fEditSeq->IAlnSequence(NULL);  //must be NULL or 1st seq gets trashed...
  350.     fEditRow= 0; 
  351.     RemoveSubView(fEditSeq);
  352.     gAlnTextStyle= fEditSeq->fTextStyle;
  353.  
  354.     /*-- SetPortTextStyle(gAlnTextStyle);  << THIS BOMBS PROG, no window here... */ 
  355.     gAlnCharWidth= CharWidth('G');   
  356.     gMaxViewCellsBugFix= kMaxCoord / (gAlnCharWidth+4);
  357.     gMaxViewCellsBugSeen= false;
  358. }
  359.  
  360.  
  361. pascal void TAlnView::UpdateSize(void)
  362. VAR      diff: longint;
  363. {
  364.     if ((fAlnList!=NULL)) {
  365.         diff= fAlnList.GetSize - fNumOfRows;
  366.         if ((diff>0)) InsRowLast( 1, fRowheight)     
  367.         else if ((diff<0)) DelRowLast( -diff);
  368.         }    else
  369.         DelRowLast( fNumOfRows);
  370. }
  371.  
  372.  
  373. pascal void TAlnView::UpdateWidth(TSequence aSeq)
  374. VAR            alnlen : longint;
  375.               TScroller        aScroll;
  376. {
  377.     alnlen= GetHandleSize(aSeq->fBases) + 30;
  378. //+?!?? trying to find bug which mangles view when > ~2000 bases 
  379.     if (alnlen>gMaxViewCellsBugFix) then gMaxViewCellsBugSeen= true;
  380.     alnlen= Min( gMaxViewCellsBugFix, alnlen); 
  381.     if alnlen > fNumOfCols then InsColLast( alnlen-fNumOfCols, gAlnCharWidth);  
  382.     SetColWidth(1, fNumOfCols, gAlnCharWidth);  
  383.     if (fAlnDoc!=NULL) && (fAlnDoc->fAlnHIndex!=NULL))
  384.         fAlnDoc->fAlnHIndex->UpdateWidth(); //keep ruler in sync
  385. }
  386.  
  387. pascal void TAlnView::UpdateAllWidths(void)
  388. VAR            alnlen : longint;
  389.               TScroller        aScroll;
  390.         pascal void findMaxLength( TSequence aSeq)
  391.         {
  392.             alnlen= Max( alnlen, GetHandleSize(aSeq->fBases));
  393. //+?!?? trying to find bug which mangles view when > ~2000 bases 
  394.             if (alnlen>gMaxViewCellsBugFix) then gMaxViewCellsBugSeen= true;
  395.             alnlen= Min( gMaxViewCellsBugFix, alnlen); 
  396.         }
  397. {
  398.     alnlen= 0;
  399.     fAlnList->Each( findMaxLength);
  400.     alnlen= alnlen + 30; 
  401.     if alnlen > fNumOfCols then InsColLast( alnlen-fNumOfCols, gAlnCharWidth);  
  402.     SetColWidth(1, fNumOfCols, gAlnCharWidth);  
  403.     if (fAlnDoc!=NULL) && (fAlnDoc->fAlnHIndex!=NULL))
  404.         fAlnDoc->fAlnHIndex->UpdateWidth(); //keep ruler in sync
  405. }
  406.  
  407.  
  408. pascal void TAlnView::DeInstallEditSeq(void)
  409. VAR      lastCmd    : TCommand;
  410.             VRect        vbounds;
  411. {
  412.     if ((fEditRow!=0)) { 
  413.       // uninstall old editrow 
  414.         // Commit the last command to prevent undo from applying to the wrong edit text 
  415.         lastCmd= gApplication->GetLastCommand();
  416.         if ((lastCmd != NULL) && (lastCmd->fContext == fEditSeq))
  417.             gApplication->CommitLastCommand();
  418.         UpdateWidth(fEditSeq->fSeq);
  419.         fEditSeq->DeInstall();            
  420.         RemoveSubView(fEditSeq);
  421.  
  422.         if (TAlnDoc(GetWindow->fDocument).fUseColor) {
  423.             //Partial fix for lack of TEDrawHook...
  424.             RowToVRect( fEditRow, 1, vbounds);
  425.             InvalidateVRect( vbounds);
  426.             }
  427.             
  428.         fEditRow= 0;
  429.         }
  430. }
  431.  
  432.  
  433. pascal void TAlnView::InstallEditSeq(integer row, selStart,selEnd, boolean doLight)
  434. VAR
  435.     VRect        vbounds ;
  436.     Rect        qdbounds;
  437.     aSeq        : TSequence;
  438.     aCell        : GridCell;
  439.     vp            : Vpoint;
  440. {
  441.     DeInstallEditSeq();
  442.  
  443.     fEditRow= row;
  444.     if ((row != 0)) {
  445.         aSeq= TSequence(fAlnList->At( row));
  446.         RowToVRect( row, 1, vbounds);
  447.         //- ViewToQDRect( vbounds, qdbounds); *//*???
  448.         
  449.         AddSubView( fEditSeq);  //?! must do before locate/resize so suview is set
  450.        if (fEditSeq->Focus()) ; //??
  451.  
  452.         fEditSeq->ReplaceSeq( aSeq);
  453.  
  454.         WITH vbounds){ //was qdbounds
  455.             SetVpt( vp, left, top);
  456.             fEditSeq->Locate( vp, kDontRedraw);
  457.             SetVpt( vp, right-left,bottom-top);
  458.             fEditSeq->Resize( vp, kDontRedraw);
  459.             }
  460.             
  461.         SetSelect( selStart, selEnd, fEditSeq->fHTE);  
  462.         if (doLight) {
  463.             aCell.h= selStart+1; 
  464.             aCell.v= row;
  465.           SelectCell( aCell, FALSE, TRUE, TRUE);
  466.             ScrollSelectionIntoView( TRUE); //< redraw does highlight !
  467.           SelectCell( aCell, FALSE, TRUE, FALSE); //turn off highlight
  468.  
  469.             //- fEditSeq->InstallSelection(FALSE, TRUE);
  470.             //- TESetSelect( selStart, selEnd, fEditSeq->fHTE);
  471.             }
  472.     
  473.         if (fEditSeq->BecomeTarget()) ; // GetWindow->SetTarget(fEditSeq); 
  474.         }
  475. }
  476.  
  477. pascal void TAlnView::registerInsertLast( TSequence aSeq)
  478. {
  479.     InsRowLast( 1, fRowheight);    
  480.     UpdateWidth(aSeq);    
  481. }
  482.  
  483. pascal void TAlnView::addToAlnList( TSequence aSeq)
  484. VAR  aRect: VRect;
  485. {
  486.     fAlnList->InsertLast( aSeq);
  487.     //-- registerInsertLast( aSeq); 
  488.     InsRowLast( 1, fRowheight);    
  489.     UpdateWidth( aSeq);    
  490.     /*-- // insrowlast does this inval....
  491.     RowToVRect( fNumOfRows, 1, aRect);
  492.     InvalidateVRect( aRect); 
  493.     ----*/
  494. }
  495.  
  496. pascal TSequence TAlnView::SeqAt( integer aRow)  
  497. {
  498.     SeqAt= TSequence(fAlnList->At( aRow));  
  499. }
  500.  
  501.  
  502. pascal void TAlnView::MakeConsensus(void)
  503. VAR
  504.     arow    : integer;
  505.     arect    : VRect;
  506. {
  507.     fAlnList->MakeConsensus();
  508.     arow= fAlnList->ConsensusRow();
  509.     if ((arow>0)) {
  510.         RowToVRect( arow, 1, aRect);
  511.         InvalidateVRect( aRect);
  512.         }
  513. }
  514.  
  515.  
  516. pascal charsHandle TAlnView::FindCommonBases( integer minCommonPerCent)
  517. VAR  hFirst: CharsHandle;
  518. {
  519.     gMinCommonPercent= minCommonPerCent;
  520.     FindCommonBases= fAlnList->FindCommonBases(minCommonPercent, hFirst);
  521.     Handle(hFirst)= DisposeIfHandle( hFirst);
  522. }
  523.  
  524.  
  525. pascal void TAlnView::Close(void) /* override */ 
  526. {
  527.         DeInstallEditSeq();
  528.         inherited::Close();
  529. }
  530.  
  531. pascal void TAlnView::HiliteCommonBases(void)
  532. var  
  533.     TSequence        cons;
  534.     CharsHandle        hCon, hSeq, hFirst;
  535.     longint        len, maxlen, conlen, ibase;
  536.     arow    : integer;
  537.     integer        nseq ;
  538.     CharsHandle        hMaxbase;
  539.     
  540.         procedure markCommon(TSequence aSeq)
  541.         integer        var ibase;
  542.                 char        ch;
  543.                 gridCell        aCell;
  544.         {
  545.             nseq= nseq+1;
  546.             if !(aSeq.isConsensus || (aSeq->fKind=kOtherSeq)) then begin
  547.                 handle(hSeq)= aSeq->fBases;
  548.                 //- len= GetHandleSize(Handle(hSeq));
  549.                 for ibase= 0 to maxlen-1 do  
  550.                  if (UprChar((*hSeq)^[ibase]) == (*hMaxbase)^[ibase]) then begin
  551.                   aCell.h= ibase+1;
  552.                   aCell.v= nseq;
  553.                   this->SelectCell( aCell, TRUE, !kHighlight, TRUE);
  554.                     }
  555.                 }
  556.         }
  557.         
  558. {
  559.     cons= fAlnList->Consensus();
  560.     if ((cons=NULL)) cons= TSequence(fAlnList->First());
  561.  
  562.     if ((cons!=NULL)) {
  563.         arow= fAlnList->GetIdentityItemNo( cons);
  564.         handle(hCon)= cons->fBases;   
  565.         
  566.         hMaxBase= fAlnList->FindCommonBases(gMinCommonPercent, hFirst); 
  567.         
  568.         maxlen= GetHandleSize(handle(hMaxBase));
  569.         this->InvalidateSelection();
  570.         this->SetEmptySelection( !kHighlight);        
  571.         nseq= 0;
  572.         fAlnList->Each( markCommon);
  573.         this->InvalidateSelection();
  574.         DisposHandle(    handle(hMaxBase)); 
  575.         DisposHandle(    handle(hFirst)); 
  576.         }
  577. }
  578.  
  579.  
  580.  
  581. #pragma segment ARes
  582.  
  583. pascal void TAlnView::Free(void) // override 
  584. VAR     itsEditSeq: TAlnSequence;
  585. {
  586.     FreeData();
  587.     fAlnList= NULL; //! fAlnList == fSeqList is owned by Doc !
  588.     
  589.     itsEditSeq= fEditSeq;     
  590.     if ((itsEditSeq != NULL) && (itsEditSeq->fSuperView != NULL))
  591.         itsEditSeq->fSuperView->RemoveSubView(itsEditSeq);
  592.  
  593.     inherited::Free();
  594.     TObject(itsEditSeq)= FreeIfObject(itsEditSeq);                     
  595. }
  596.  
  597. pascal void TAlnView::FreeData(void)
  598. {
  599.     //!! TAlnView doesn't own fAlnList data ! is just ptr to fDoc->fSeqList 
  600. }
  601.  
  602.  
  603. /************
  604. procedure myDrawAln( charsPtr pText, integer indx, len)
  605. var
  606.     integer        endx, i ;
  607.     ch    : char;
  608.  
  609.     integer        cw, pend, skip;
  610.     grafPtr        aPort;
  611.     pt    : point;
  612. {
  613.     cw= gAlnCharWidth;
  614.     getpen( pt);
  615.     if pt.h < 0 then begin
  616.         skip= (-pt.h) / cw;
  617.       indx= indx + skip;
  618.         len= len - skip;
  619.         move( skip*cw, 0);
  620.         end();
  621.     pend= len * cw;
  622.     GetPort(aPort);
  623.     if pend > aPort->portRect.right then begin
  624.         skip= (pend - aPort->portRect.right) / cw;
  625.         len= len - skip;
  626.         end();
  627.             
  628.     endx= indx + len - 1;
  629.     for i= indx to endx do begin
  630.         ch= (*pText)[i];
  631.         case ch of
  632.             'A','a': RGBForeColor( gAcolor);
  633.             'C','c': RGBForeColor( gCcolor);
  634.             'G','g': RGBForeColor( gGcolor);
  635.             'T','t',
  636.             'U','u': RGBForeColor( gTcolor);
  637.             otherwise
  638.                              RGBForeColor( gNcolor);
  639.             end();
  640.      DrawChar(ch);
  641.     //_ if (indx mod 10 == 9) then DrawChar(' '); *//*spacer ??
  642.      end();
  643. end; //myDrawAln
  644. *******/
  645.  
  646.  
  647. pascal void DrawAlnColors(colorsArray VAR colors, Boolean swapBackColor,
  648.                                 charsPtr        pText; integer indx, len)
  649. VAR
  650.     longint        endx, i ;
  651.     ch, lastch    : char;
  652.     longint        cw, pend, skip;
  653.     grafPtr        aPort;
  654.     pt    : point;
  655. {
  656.     cw= gAlnCharWidth;
  657.     getpen( pt);
  658.     if (pt.h < 0) {
  659.         skip= (-pt.h) / cw;
  660.       indx= indx + skip;
  661.         len= len - skip;
  662.         move( skip*cw, 0);
  663.         }
  664.     pend= len * cw;
  665.     GetPort(aPort);
  666.     if (pend > aPort->portRect.right) {
  667.         skip= (pend - aPort->portRect.right) / cw;
  668.         len= len - skip;
  669.         }
  670.             
  671.     endx= indx + len - 1;
  672.     /*-- backcolor not showing -- need erase or something...
  673.     if ((swapBackcolor)) RGBForeColor( colors[' '])
  674.     else RGBBackColor( colors[' ']);
  675.     ---*/
  676.     
  677.     lastch= ((char)(0));
  678.     FOR i= indx to endx do {
  679.         ch= (*pText)[i];
  680.         /*- if ((swapBackcolor)) RGBBackColor( colors[ch])
  681.         else */
  682.         if ((ch!=lastch)) RGBForeColor( colors[ch]);
  683.         DrawChar(ch);
  684.         lastch= ch;
  685.         }
  686. } 
  687.  
  688.  
  689.  
  690. pascal void TAlnView::DrawCell(aCell:GridCell; VRect aRect)
  691.             // override 
  692. VAR
  693.         TAlnSequence        aSeq;
  694.         Handle        hText;
  695.         longint        len ;
  696.         TextStyle        aTextStyle;
  697. {
  698. /*----
  699.   if (fAlnList!=NULL) && (aCell.v <= fAlnList->fSize) then begin
  700.         aSeq= TAlnSequence(fAlnList->at(aCell.v));
  701.         if aSeq!=NULL then begin
  702.             aTextStyle = aSeq->fTextStyle;
  703.             SetPortTextStyle(aTextStyle);
  704.         
  705.             moveto( aRect.left, aRect.bottom-4);  
  706.             hText= aSeq->fSeq.fBases;
  707.             len= GetHandleSize(hText);
  708.             HLock(hText);
  709.             myDrawAln( charsPtr((*hText)), 0, len);
  710.             HUnlock(hText);
  711.             end();
  712.         end();
  713. -------*/
  714. }
  715.  
  716.  
  717.  
  718. //+?!?? trying to find bug which mangles view when > ~2000 bases 
  719. pascal void TAlnView::CellToVRect( GridCell aCell, VRect VAR aRect) // override 
  720. VAR
  721.          longint        width; //! these where shorts 
  722.         longint        height;
  723. {
  724.     inherited::CellToVRect( aCell, aRect);
  725. /***
  726.     if ((aCell.h < 1) || (aCell.v < 1) 
  727.     || (aCell.h > fNumOfCols) || (aCell.v > fNumOfRows))) 
  728.         aRect= gZeroVRect 
  729.     else {                             
  730.         width= fColWidths->GetValue(aCell.h);
  731.         aRect.left= width * (aCell.h - 1);
  732.         /*+ if (fColWidths->fNoOfChunks == 1) then  
  733.             aRect.left= width * (aCell.h - 1) 
  734.         else
  735.          aRect.left= fColWidths->SumValues(1, aCell.h - 1);
  736.         */
  737.  
  738.         aRect.right= aRect.left + width;
  739.  
  740.         height= fRowHeights->GetValue(aCell.v);
  741.         if (fRowHeights->fNoOfChunks == 1) then
  742.             aRect.top= height * (aCell.v - 1) 
  743.         else
  744.             aRect.top= fRowHeights->SumValues(1, aCell.v - 1);
  745.         aRect.bottom= aRect.top + height;
  746.         }
  747. ***/
  748. }
  749.  
  750. //+?!?? trying to find bug which mangles view when > ~2000 bases 
  751. pascal TAlnView::VPointToLastCell( aPoint: VPoint):GridCell; // override 
  752. VAR  aCell: GridCell;  longint lwidth,
  753. {
  754.     VPointToLastCell= inherited::VPointToLastCell( aPoint);
  755. /***
  756.     //+ aCell.h= fColWidths->FindItem(aPoint.h);
  757.     aCell.h= 0;
  758.     if ((aPoint.h >= 0) && (aPoint.h <= fColWidths->fTotal))) {
  759.             if (fColWidths.(*fChunks)^[0].value > 0)) {
  760.                 lwidth= 1 +  (aPoint.h - 1) / fColWidths.(*fChunks)^[0].value;
  761.                 lwidth= Min( lwidth, fColWidths->fNoOfItems); 
  762.                 if (lwidth>Maxint) then aCell.h= Maxint
  763.                 else aCell.h= lwidth;
  764.                 }            }        else if (aPoint.h == 0) then
  765.             aCell.h= 1;
  766.     
  767.     if (aCell.h == 0) then aCell.h= fNumOfCols;
  768.  
  769.     aCell.v= fRowHeights->FindItem(aPoint.v);
  770.     if (aCell.v == 0) then aCell.v= fNumOfRows;
  771.  
  772.     VPointToLastCell= aCell;
  773. ***/
  774. }
  775.  
  776. //+?!?? trying to find bug which mangles view when > ~2000 bases 
  777. pascal Boolean TAlnView::Focus(void) // override 
  778. VAR
  779.          Point        aPt, bPt, deltaOrigin;
  780.          Rect        visQDRect;
  781.          
  782. {
  783.     Focus= inherited::Focus;
  784. /****
  785.     if (this->IsFocused()))    
  786.         Focus= TRUE 
  787.  
  788.     else if (this->FocusOnSuperView())) {
  789.          //? don't do it -- use superview focus here ?!?!?
  790.  
  791.         SetOrigin(fQDOrigin.h, fQDOrigin.v);     
  792.         if ((gCurrPrintHandler != NULL) && (gCurrPrintHandler->fView == this))) {
  793.             //- deltaOrigin= fQDOrigin - gCurrPrintHandler.GetQDOrigin
  794.             aPt= fQDOrigin;
  795.             bPt= gCurrPrintHandler->GetQDOrigin();
  796.             SubPt( bPt, aPt);
  797.             deltaOrigin= bPt;
  798.             }        else if (fSuperView!=NULL)) {
  799.             //- deltaOrigin= fQDOrigin - fSuperView->fQDOrigin
  800.             aPt= fQDOrigin;
  801.             bPt= fSuperView->fQDOrigin;
  802.             SubPt( bPt, aPt);
  803.             deltaOrigin= bPt;
  804.             }        else
  805.             deltaOrigin= gZeroPt;
  806.  
  807.         gFocusedView= this;        // Now we have the basic focus 
  808.  
  809.         //- // Add the clipping 
  810.         /*--
  811.         this->GetVisibleQDRect(visQDRect);
  812.         this->OffsetAndClipFurtherTo(visQDRect, deltaOrigin);
  813.          ---*/
  814.      
  815.         Focus= TRUE;
  816.         }    else     
  817.         Focus= FALSE;
  818. ***/
  819. }
  820.  
  821. //+?!?? trying to find bug which mangles view when > ~2000 bases 
  822. pascal void TAlnView::UpdateCoordinates(void) // override 
  823. CONST  kMaxOriginFixup == 16000; //was 1024; // The maximum amount by which to _fixup_
  824. VAR
  825.          VPoint        localOriginInSuper, aVpt;
  826.          VPoint        actualViewToQDOffset;
  827.          VRect        itsExtent, aVRect;
  828.          Point        deltaOrigin, aPt; 
  829.          VRect        itsFrame, visibleExtent;
  830. {
  831.     inherited::UpdateCoordinates();
  832. /***
  833.     this->GetLocalOffsetInSuper(localOriginInSuper);
  834.  
  835.     if (gCurrPrintHandler!=NULL) && (gCurrPrintHandler->fView == this)
  836. ) {
  837.         gCurrPrintHandler->GetViewToQDOffset(actualViewToQDOffset);
  838.         /*- actualViewToQDOffset = actualViewToQDOffset + 
  839.             VPoint(gCurrPrintHandler->GetQDOrigin()); */
  840.         PtToVPt(gCurrPrintHandler->GetQDOrigin(), aVpt);
  841.         AddVPt(aVpt, actualViewToQDOffset);
  842.         }    else {
  843.         /*- actualViewToQDOffset = fSuperView->fViewToQDOffset + VPoint(fSuperView->fQDOrigin) 
  844.                         - localOriginInSuper;*/
  845.         PtToVPt(fSuperView->fQDOrigin, actualViewToQDOffset);
  846.         aVPt= fSuperView->fViewToQDOffset;
  847.         AddVPt(aVPt, actualViewToQDOffset);
  848.         SubVPt(localOriginInSuper, actualViewToQDOffset);
  849.         }            
  850.         
  851.     fViewToQDOffset= actualViewToQDOffset;     
  852.     this->GetExtent(itsExtent);
  853.     //- if (VRect(-kMaxCoord,-kMaxCoord, kMaxCoord, kMaxCoord)->Contains(itsExtent))
  854.     if (itsExtent.left >= -kMaxCoord) && (itsExtent.right <= kMaxCoord)
  855.         && (itsExtent.top <= -kMaxCoord) && (itsExtent.bottom <= kMaxCoord)
  856. ) {
  857.         //-fQDOrigin= actualViewToQDOffset->ToPoint();
  858.         aPt= fQDOrigin;
  859.         SetPt( aPt, actualViewToQDOffset.h, actualViewToQDOffset.v);
  860.         fViewToQDOffset= gZeroVPt;
  861.         }    else {
  862.         SetPt( deltaOrigin, 
  863.                     (actualViewToQDOffset.h % kMaxOriginFixup), 
  864.                     (actualViewToQDOffset.v % kMaxOriginFixup) );
  865.         //- fViewToQDOffset= actualViewToQDOffset - VPoint(deltaOrigin);
  866.         PtToVPt( deltaOrigin, aVpt);
  867.         fViewToQDOffset= VPtSubVPt( actualViewToQDOffset, aVPt);
  868.         fQDOrigin= deltaOrigin;
  869.         }
  870.  
  871.     if ((gDrawingPictScrapView == this) || ((gCurrPrintHandler != NULL) && (gCurrPrintHandler->fView == this)))
  872. ) {
  873.         this->GetExtent(itsExtent);
  874.         fVisibleExtent= itsExtent;
  875.         }    else {
  876.         this->GetFrame(itsFrame);
  877.         //- visibleExtent= itsFrame && fSuperView->fVisibleExtent;
  878.         aVrect= fSuperView->fVisibleExtent;
  879.         if (SectVRect(itsFrame, aVrect, visibleExtent)) ;
  880.         this->SuperToLocalVRect(visibleExtent);
  881.         fVisibleExtent= visibleExtent;
  882.         }
  883. *****/        
  884. }
  885.  
  886.  
  887. //+?!?? trying to find bug which mangles view when > ~2000 bases 
  888. pascal void TAlnView::Draw(VRect area) /* override */ 
  889. VAR
  890.     VRect        aRect, bRect;
  891.     GridCell        startCell, stopCell, startCellToDraw;
  892.     VRect        cellsArea, localArea;
  893. {
  894.     inherited::Draw( area);
  895. /*****
  896.     if ((fNumOfRows > 0) && (fNumOfCols > 0))) {
  897.  
  898.         startCell= this->VPointToLastCell(area.topLeft);
  899.         stopCell = this->VPointToLastCell(area.botRight);
  900.  
  901.         this->CellToVRect(startCell, aRect);
  902.         this->CellToVRect(stopCell, bRect);
  903.         bRect.top= aRect.top; 
  904.         bRect.left= aRect.left; //[topLeft]= aRect[topLeft];
  905.         localArea= bRect;
  906.  
  907.         startCellToDraw= startCell;
  908.         cellsArea= localArea;
  909.         if (area.top >= aRect.bottom - (fRowInset / 2))) {
  910.             startCellToDraw.v= startCellToDraw.v + 1;
  911.             cellsArea.top=  cellsArea.top + (aRect.bottom - aRect.top); //GetLength(vSel);
  912.             }
  913.  
  914.         this->DrawRangeOfCells(startCellToDraw, stopCell, cellsArea);
  915.         }
  916. ****/
  917. }
  918.  
  919.  
  920.  
  921.  
  922. pascal void TAlnView::DrawRangeOfCells(GridCell startCell, stopCell, VRect aRect) 
  923.                                         // override */ /*from TGridView method
  924. VAR
  925.     colWidth, rowHeight, qdleft    : longint;
  926.     vleft            : longint;
  927.   TextStyle        aTextStyle;
  928.     Rect        aQDRect;
  929.  
  930.     function showA( c: char): char;
  931.     begin     if (c='A') || (c='a') then showA= c else showA= ' ';
  932.     end();
  933.     function showC( c: char): char;
  934.     begin     if (c='C') || (c='c') then showC= c else showC= ' ';
  935.     end();
  936.     function showG( c: char): char;
  937.     begin     if (c='G') || (c='g') then showG= c else showG= ' ';
  938.     end();
  939.     function showT( c: char): char;
  940.     begin     
  941.         if (c in ['T','t','U','u']) then showT= c else showT= ' ';
  942.     end();
  943.     function showN( c: char): char;
  944.     begin     
  945.         if (c in ['A','a','C','c','G','g','T','t','U','u'])
  946.                     then showN= ' ' else showN= c;
  947.     end();
  948.     function showEach( c: char): char;
  949.     begin     showEach= c;
  950.     end();
  951.  
  952.  procedure DrawOneColor(function showChar(c:char):char);
  953.     const
  954.         maxbuf    == 500; //are any displays wider than maxbuf*charwidth?
  955.  var
  956.          longint        i, j, ibeg, iend, rowtop, rowbot;
  957.         len            : longint;
  958.         aSeq        : TSequence;
  959.         hSeq        : CharsHandle;
  960.         cbuf        : packed array [0..maxbuf] of char;
  961.  begin
  962.     ibeg= startCell.h - 1;
  963.     iend= stopCell.h;
  964.  
  965.     rowtop= aRect.top;
  966.     FOR j = startCell.v TO stopCell.v){
  967.         rowbot = rowtop + rowHeight - fRowInset;  
  968.         aSeq= TSequence(fAlnList->at(j));
  969.         if (aSeq!=NULL) && (aSeq->fBases!=NULL) then begin
  970.             handle(hSeq)= aSeq->fBases;
  971.             len= min(maxbuf, min( GetHandleSize(handle(hSeq)),iend) - ibeg);
  972.             for i= 0 to len-1 do cbuf[i]= showChar((*hSeq)^[i+ibeg]);
  973.             
  974.             moveto( qdleft+1, rowbot-5); //<< fix fudged v !
  975.             
  976.             DrawText( &cbuf, 0, len);
  977.             end();
  978.         rowtop = rowbot + fRowInset;
  979.         }
  980.     end(); //DrawOneColor
  981.  
  982.  pascal void DrawAllColors(void)
  983.  VAR
  984.          longint        i, j, ibeg, iend, rowtop, rowbot;
  985.         len            : longint;
  986.         aSeq        : TSequence;
  987.         hSeq        : CharsHandle;
  988.  {
  989.     ibeg= startCell.h - 1;
  990.     iend= stopCell.h;
  991.     rowtop= aQDRect.top;
  992.     FOR j = startCell.v TO stopCell.v){
  993.         rowbot = rowtop + rowHeight - fRowInset;  
  994.         aSeq= TSequence(fAlnList->at(j));
  995.         if ((aSeq!=NULL) && (aSeq->fBases!=NULL)) {
  996.             handle(hSeq)= aSeq->fBases;
  997.             len= min( GetHandleSize(handle(hSeq)),iend) - ibeg;
  998.             moveto( qdleft+1, rowbot-5); //<< fix fudged v !
  999.             if ((aSeq->fKind == kAmino))
  1000.                 DrawAlnColors(gAAcolors, gSwapBackground, (*hSeq), ibeg, len)
  1001.             else
  1002.                 DrawAlnColors(gNAcolors, gSwapBackground, (*hSeq), ibeg, len);
  1003.             }
  1004.         rowtop = rowbot + fRowInset;
  1005.         }
  1006.     } //DrawAllColors
  1007.         
  1008. {
  1009.     aRect.left = aRect.left + ((fColInset) >> 1);    // fColInset / 2 
  1010.     aRect.top = aRect.top + ((fRowInset) >> 1);     // fRowInset / 2 
  1011.     /***
  1012.     LocalToWindow( aRect.topleft); //+ ?? mapp3 fix for bad aRect ???
  1013.     LocalToWindow( aRect.botright); /*+ sort of -- window coords are not correct
  1014.             as drawing is done rel. to localview(0,0), but we draw parts of
  1015.             all of long sequence now -- BUT we still get crash when view scrolled
  1016.             to the long sequence -- TScroller problem ???*/
  1017.             //+ !! somewhere someone is probably doing short/int overflow by mistake !
  1018.     ***/  
  1019.     
  1020.     VRectToRect( aRect, aQDRect); //??? do we want this -- truncs at maxint 
  1021.     qdleft         = aQDRect.left;
  1022.     colWidth  = GetColWidth(1);
  1023.     rowHeight = GetRowHeight(1); //fails w/ fNumOfRows=0 !
  1024.  
  1025.     //! need to let TE do its hightlighting... don't need TEDeact??
  1026.   if (fEditRow != 0) {
  1027.        if (fEditSeq->Focus()) ; //??
  1028.         fEditSeq->Show(TRUE,FALSE);  
  1029.         //- if fEditSeq.Focus then TEDeactivate(fEditSeq->fHTE); ---
  1030.         if (Focus) ;
  1031.         }
  1032.         
  1033.     SetPortTextStyle(gAlnTextStyle);
  1034.  
  1035.     if TAlnDoc(GetWindow->fDocument).fUseColor then begin
  1036.         /* DrawAllColors is slower than DrawOneColor x 5 
  1037.             -- do DrawOne for nucs ??*/
  1038.         DrawAllColors(); 
  1039.         /*--
  1040.         RGBForeColor( gAcolor); DrawOneColor(showA);
  1041.         RGBForeColor( gCcolor); DrawOneColor(showC);
  1042.         RGBForeColor( gGcolor); DrawOneColor(showG);
  1043.         RGBForeColor( gTcolor); DrawOneColor(showT);
  1044.       RGBForeColor( gNcolor); DrawOneColor(showN);
  1045.         ---*/
  1046.         end
  1047.     else
  1048.         DrawOneColor(showEach);
  1049.     
  1050.     if (fEditRow != 0) begin
  1051.       if fEditSeq.Focus then TEActivate(fEditSeq->fHTE);  
  1052.         if Focus then ;
  1053.         }
  1054. }
  1055.  
  1056.  
  1057.  
  1058. pascal void TAlnView::DrawContents(void) // override 
  1059. {
  1060.     //?? if ((fEditSeq!=NULL)) fEditSeq->show(FALSE,FALSE);  
  1061.     inherited::DrawContents();
  1062.   /*?? if ((fEditSeq!=NULL)) fEditSeq->show(TRUE,FALSE);  */ 
  1063. }
  1064.  
  1065.  
  1066. pascal void TAlnView::CalcMinFrame(VRect VAR minFrame) // override 
  1067. {
  1068.     inherited::CalcMinFrame( minFrame);
  1069.     /*----
  1070.     minFrame.right=  max(minFrame.right, 10 + fNumOfCols * gAlnCharWidth);
  1071.     minFrame.bottom=  max(minFrame.bottom, 10 + fNumOfRows * GetRowHeight(1));
  1072.     -----*/
  1073. }
  1074.  
  1075.  
  1076.  
  1077. pascal void TAlnView::DoMouseCommand(VPoint VAR theMouse, TToolboxEvent event,
  1078.                                                Point hysteresis) // override 
  1079. VAR
  1080.     aRow, aCol    : short;
  1081.     aCell    : GridCell;
  1082.     aAlnSlider        : TAlnSlider;
  1083.     boolean        aDoubleClick;
  1084.     vpt        : VPoint;
  1085.     GridViewPart        gridPart;    
  1086. {
  1087.     aDoubleClick= event->fClickCount > 1;
  1088.     gridPart= IdentifyPoint(theMouse, aCell);
  1089.     aCol= aCell.h;
  1090.     
  1091.     if (aDoubleClick) {
  1092.         inherited::DoMouseCommand(theMouse,event,hysteresis); 
  1093.         }        
  1094.     else if ((event.IsShiftKeyPressed |event.IsCommandKeyPressed 
  1095.                 || event->IsOptionKeyPressed())) { 
  1096.         inherited::DoMouseCommand(theMouse,event,hysteresis);
  1097.         }        
  1098.     else if (gridPart != badChoice) {
  1099.         aCell    = VPointToLastCell(theMouse);
  1100.         //if TRUE then begin
  1101.         if (isCellSelected(aCell)) {
  1102.             New(aAlnSlider);
  1103.             FailNIL(aAlnSlider);
  1104.             aAlnSlider->IAlnSlider(this, aCol);
  1105.             PostCommand( aAlnSlider);
  1106.             }        else {
  1107.             SetEmptySelection(kHighlight);
  1108.             event->fEventRecord.modifiers = bOr(event->fEventRecord.modifiers,shiftKey);
  1109.                  //!? mimic shiftIsDown when no selection ... ?
  1110.             inherited::DoMouseCommand(theMouse,event,hysteresis); 
  1111.             }
  1112.         }
  1113. }
  1114.  
  1115.  
  1116.  
  1117. pascal TAlnView::HandleMouseDown( VPoint theMouse, TToolboxEvent event, 
  1118.                              hysteresis: Point):Boolean; // override 
  1119. VAR
  1120.         aCell    : GridCell;
  1121. {        
  1122.     if (!(fLocked || event.IsShiftKeyPressed || event.IsCommandKeyPressed 
  1123.         || event->IsOptionKeyPressed())) {  
  1124.         SetEmptySelection(kHighlight); 
  1125.         if (fAlnDoc->fAlnIndex!=NULL) fAlnDoc->fAlnIndex->SetEmptySelection(kHighlight); 
  1126.         aCell= VPointToLastCell(TheMouse);
  1127.         InstallEditSeq(aCell.v,0,0,FALSE);
  1128.         }
  1129.     
  1130.   HandleMouseDown= inherited::HandleMouseDown(theMouse,event,hysteresis);
  1131. }
  1132.         
  1133.  
  1134. pascal Boolean TAlnView::ContainsClipType(ResType aType) // override 
  1135. {
  1136.     ContainsClipType = aType == kAlnScrapType;
  1137.     //!? also (aType == 'TEXT') can be pasted as seq... w/ SeqReadScrap...
  1138. }
  1139.  
  1140. pascal void TAlnView::WriteToDeskScrap(void) // override 
  1141. VAR
  1142.         textScrap    : Handle;
  1143.         err                : OSErr;
  1144.         format        : integer;
  1145. {
  1146.     format= kGenBank;
  1147.     /*--- ??? causing bombs here !!!
  1148.     if (fAlnDoc->fFormatPop == NULL) format= kGenBank
  1149.     else format= fAlnDoc->fFormatPop.fCurrentItem; 
  1150.     ---*/
  1151.     fAlnList->ClearSelections();
  1152.     textScrap= fAlnList->doWriteHandle( format);  
  1153.     err = gClipboardMgr->PutDeskScrapData('TEXT', textScrap);
  1154.     textScrap = DisposeIfHandle(textScrap);
  1155.     FailOSErr(err);
  1156. }
  1157.  
  1158.  
  1159.  
  1160.         
  1161.  
  1162.  
  1163.  
  1164. // TAlnSlider --------------------------------------
  1165.  
  1166. pascal void TAlnSlider::IAlnSlider( TAlnView itsAlnView, integer atRC)
  1167. {
  1168.     fAlnView= itsAlnView;    
  1169.     fOldSeqs= NULL;
  1170.     fNewSeqs= NULL;
  1171.     fOldSelection= NULL;
  1172.     fNewSelection= NULL;
  1173.     
  1174.     IRCShifter(itsAlnView->fDocument, itsAlnView, NULL, h, atRC);
  1175.     fCausesChange= TRUE; //!? fix since RCShifter thinks we make no changes
  1176.     
  1177.     fOldSeqs= TSeqList(NewList); FailNIL( fOldSeqs);
  1178.     fNewSeqs= TSeqList(NewList); FailNIL( fNewSeqs);
  1179.     fOldSelection= NewRgn; FailNil( fOldSelection);
  1180.     fNewSelection= NewRgn; FailNIL( fNewSelection);
  1181.     CopyRgn( itsAlnView->fSelections, fOldSelection);
  1182.     CopyRgn( fOldSelection, fNewSelection);
  1183. }
  1184.  
  1185. pascal void TAlnSlider::Free(void) // override 
  1186. {
  1187.     if ((fNewSeqs!=NULL)) {
  1188.         fNewSeqs->DeleteAll(); //forget objects -- doesn't affect objects 
  1189.         fNewSeqs->Free(); //drop list, not objects
  1190.         }
  1191.     if ((fOldSeqs!=NULL)) fOldSeqs->FreeList(); //drop all objects && list
  1192.     if ((fOldSelection!=NULL)) DisposeRgn( fOldSelection);
  1193.     fOldSelection= NULL;
  1194.     if ((fNewSelection!=NULL)) DisposeRgn( fNewSelection);
  1195.     fNewSelection= NULL;
  1196.     
  1197.     inherited::Free();
  1198. }
  1199.  
  1200.  
  1201. pascal TTracker TAlnSlider::TrackMouse(TrackPhase aTrackPhase, VAR anchorPoint, previousPoint,
  1202.                                  VPoint        nextPoint; Boolean mouseDidMove) // override 
  1203. VAR
  1204.     GridCell        aCell;
  1205.     
  1206.     pascal void DoSlide(void)
  1207.     VAR
  1208.         aCell    : GridCell;
  1209.         longint        start, nbases;
  1210.         integer        left, right, dist, aRow;
  1211.         oldSeq, newSeq    : TSequence;
  1212.         vLoc    : VRect;
  1213.     {
  1214.         dist= fNewRC - fOldRC;
  1215.         OffsetRgn( fNewSelection, dist, 0);
  1216.         
  1217.         left= fGrid.FirstSelectedCell.h;
  1218.         right= fGrid.LastSelectedCell.h;
  1219.         FOR aRow= fGrid.FirstSelectedCell.v TO fGrid.LastSelectedCell.v){
  1220.             aCell.h= left;
  1221.             aCell.v= aRow;
  1222.             while (aCell.h<right) && !fGrid->isCellSelected(aCell))aCell.h= aCell.h+1;
  1223.             start= aCell.h - 1;
  1224.             while (aCell.h<right) && fGrid->isCellSelected(aCell))aCell.h= aCell.h+1;
  1225.             nbases= aCell.h - start;
  1226.             if ((nBases>0)) {
  1227.                 oldSeq= fAlnView->fAlnList->SeqAt(aRow);
  1228.                 oldSeq->fIndex= aRow;
  1229.                 oldSeq->SetSelection( start, nbases);
  1230.                 
  1231.                 newSeq= oldSeq->Slide( dist); //< ?? TSeqChangeCmd !?
  1232.                 
  1233.                 oldSeq->ClearSelection();        // 12nov92 - fix for write trunc bug? 
  1234.                 if ((newSeq!=NULL)) {
  1235.                     newSeq->ClearSelection();
  1236.                     fOldSeqs->InsertLast(oldSeq);
  1237.                     fNewSeqs->InsertLast(newSeq);
  1238.                   }
  1239.                 }
  1240.             }
  1241.         }
  1242.         
  1243. {
  1244.     if (aTrackPhase == trackRelease then {
  1245.         aCell    = fGrid->VPointToLastCell(nextPoint);
  1246.         fNewRC= aCell.vh[fRowCol];
  1247.         if fNewRC != fOldRC) DoSlide;
  1248.         }
  1249.     TrackMouse = this;
  1250. }
  1251.  
  1252.  
  1253. pascal void TAlnSlider::DoIt(void) // override 
  1254. /* insert "-" at left/5'/bottom of sequence if dist>0
  1255.     squeeze out "-" at top/3' of sequence.
  1256.     If dist<0 then slide opposite direction.
  1257. */
  1258. VAR    
  1259.     integer        zeroshift, left, i;
  1260.     
  1261.     pascal void UpdateEdWinds( TSequence oldSeq, newSeq)
  1262.         pascal void checkOpenEdWinds( TWindow aWind)
  1263.         {
  1264.             if (Member(TObject(aWind), TSeqedWindow)) 
  1265.                 if (TSeqedWindow(aWind).fSequence == oldSeq) { 
  1266.                     TSeqedWindow(aWind)->ReplaceSeq(newSeq);
  1267.                     aWind->ForceRedraw();
  1268.                     }
  1269.         }
  1270.     {
  1271.         TDocument(fContext)->ForAllWindowsDo(checkOpenEdWinds);
  1272.     }
  1273.  
  1274.     pascal void ReplaceViewSeq( TSequence aSeq)
  1275.     VAR  vLoc    : VRect;
  1276.     {
  1277.         fAlnView->fAlnList->AtPut( aSeq->fIndex, aSeq);
  1278.         fAlnView->RowToVRect( aSeq->fIndex, 1, vLoc);
  1279.         fAlnView->InvalidateVRect( vLoc);
  1280.     }
  1281.     
  1282. {
  1283.     if fNewRC != fOldRC then {
  1284.         fNewSeqs->Each( replaceViewSeq);
  1285.         zeroshift= fAlnView->fAlnList->ZeroOrigin(); //!?
  1286.         if ((zeroshift!=0)) {
  1287.             // THIS is getting messy w/ undo/redo because zeroOrigin affects All seqs!
  1288.             fAlnView->UpdateAllWidths();
  1289.             left= (*fNewSelection)->rgnBBox.left;
  1290.             if (left + zeroshift <= 0) then zeroshift= -left + 1; //??
  1291.             offsetRgn( fNewSelection, zeroshift, 0); 
  1292.             fAlnView->ForceRedraw(); 
  1293.             }
  1294.         fGrid->SetSelection( fNewSelection, !kExtend, kHighlight, kSelect);
  1295.         FOR i= 1 to fNewSeqs->GetSize())UpdateEdWinds( TSequence(fOldSeqs->At(i)), TSequence(fNewSeqs->At(i)));
  1296.         fCommandDone= True;
  1297.         }
  1298. }
  1299.  
  1300.  
  1301. #pragma segment ADoCommand
  1302.  
  1303. pascal void TAlnSlider::UndoIt(void) // override 
  1304. VAR  tmp: TSeqList; RgnHandle tmpRgn,
  1305. {
  1306.     if fNewRC != fOldRC then {
  1307.         tmp= fOldSeqs; 
  1308.         fOldSeqs= fNewSeqs;
  1309.         fNewSeqs= tmp;
  1310.         tmpRgn= fOldSelection;
  1311.         fNewSelection= fOldSelection;
  1312.         fOldSelection= tmpRgn;
  1313.         DoIt();
  1314.         fCommandDone= False; 
  1315.         }
  1316. }
  1317.  
  1318.  
  1319. #pragma segment ADoCommand
  1320.  
  1321. pascal void TAlnSlider::RedoIt(void) // override 
  1322. {
  1323.     UndoIt();
  1324.     fCommandDone= True; 
  1325. }
  1326.  
  1327. pascal void TAlnSlider::Commit(void) // override 
  1328. {
  1329.     this->DoNotification();
  1330. }
  1331.  
  1332. pascal void TAlnSlider::DrawFeedback( VPoint anchorPoint, nextPoint) // override 
  1333. VAR
  1334.     RgnHandle        aSelectRgn;
  1335.     deltah     : longint;
  1336.     abounds    : VRect;
  1337.     aCell        : GridCell;
  1338. {
  1339.     // horizontal slider...
  1340.     aCell    = fGrid->VPointToLastCell(nextPoint);
  1341.     aSelectRgn= NewRgn;
  1342.     fGrid->CellsToPixels( fGrid->fSelections, aSelectRgn);
  1343.     fGrid->CellToVRect( aCell, abounds);
  1344.     deltah= abounds.left - anchorPoint.h;
  1345.     OffsetRgn( aSelectRgn, deltah, 0);
  1346.     FrameRgn( aSelectRgn);
  1347.     DisposeRgn( aSelectRgn);
  1348. }
  1349.  
  1350.  
  1351.         
  1352.         
  1353.         
  1354. // TAlnIndex     ------------------
  1355.  
  1356. pascal void TAlnIndex::GetItemText(integer anItem, str255 var aString) // override 
  1357. VAR  aSeq: TSequence;
  1358. {
  1359.      aString= '';
  1360.   if ((fAlnList!=NULL) && (anItem <= fAlnList->fSize)) {
  1361.         aSeq= TSequence(fAlnList->at(anItem));
  1362.         if aSeq!=NULL then aString= aSeq->fName;
  1363.         }
  1364. }
  1365.  
  1366. pascal void TAlnIndex::UpdateSize(void)
  1367. VAR    diff: integer;
  1368. {
  1369.     if ((fAlnView!=NULL)) {
  1370.         diff= fAlnView->fNumOfRows - fNumOfRows;
  1371.         if ((diff>0)) InsRowLast( 1, fAlnView->fRowheight)     
  1372.         else if ((diff<0)) DelItemLast( -diff);
  1373.         }    else
  1374.         DelItemLast(fNumOfRows);
  1375. }
  1376.  
  1377. pascal void TAlnIndex::ReSelect(RgnHandle indexRegion)
  1378. VAR  aCell: GridCell;
  1379. {
  1380.     /*-----
  1381.     aCell = (*indexRegion)->rgnBBox.topLeft;
  1382.     if (!IsCellVisible(aCell)) PositionAtCell(aCell);                 
  1383.     ----*/
  1384.     
  1385.     if (!EqualRect((*indexRegion)->rgnBBox, (*fSelections)->rgnBBox)) {
  1386.         /*---- ??
  1387.         WITH fAlnDoc){
  1388.             fAlnView->SetEmptySelection(kHighlight);  
  1389.             }
  1390.         -----*/
  1391.         SetSelection(indexRegion, kDontExtend, kHighlight, kSelect);
  1392.         }
  1393. }
  1394.  
  1395.  
  1396.  
  1397. pascal TAlnIndex::HandleMouseDown( VPoint theMouse, TToolboxEvent event, 
  1398.                              hysteresis: Point):Boolean; // override 
  1399. {        
  1400.     fAlnView->DeInstallEditSeq();
  1401.     fAlnView->SetEmptySelection(kHighlight); 
  1402.     
  1403.   HandleMouseDown= inherited::HandleMouseDown(theMouse,event,hysteresis);
  1404. }
  1405.  
  1406. pascal void TAlnIndex::DoMouseCommand(VPoint VAR theMouse, TToolboxEvent event,
  1407.                                                Point hysteresis) // override 
  1408. VAR
  1409.     aRow, aCol    : short;
  1410.     aCell    : GridCell;
  1411.     aAlnShifter        : TAlnShifter;
  1412.     boolean        aDoubleClick;
  1413.     aName    : Str255;
  1414.     vpt        : VPoint;
  1415.     GridViewPart        gridPart;
  1416.     aSeq    : TSequence;
  1417.     
  1418. {
  1419.     aDoubleClick= event->fClickCount > 1;
  1420.     gridPart= IdentifyPoint(theMouse, aCell);
  1421.     aRow= aCell.v;
  1422.     
  1423.     if (aDoubleClick) {
  1424.         aSeq= TSequence(fAlnList->At(aRow));
  1425.         if (aSeq!=NULL)) TAlnDoc(fDocument)->OpenSeqedWindow(aSeq);
  1426.         }        
  1427.     else if ((event.IsShiftKeyPressed |event->IsCommandKeyPressed())) { 
  1428.         inherited::DoMouseCommand(theMouse,event,hysteresis) 
  1429.         }        
  1430.     else if (gridPart != badChoice) {
  1431.         aCell    = VPointToLastCell(theMouse);
  1432.         //if TRUE then begin
  1433.         if (isCellSelected(aCell)) {
  1434.             GetItemText(aRow, aName);
  1435.             New(aAlnShifter);
  1436.             FailNIL(aAlnShifter);
  1437.             aAlnShifter->IAlnShifter(this, fAlnView, aRow, aName);
  1438.             PostCommand( aAlnShifter);
  1439.             }        else
  1440.             inherited::DoMouseCommand(theMouse,event,hysteresis); 
  1441.         }
  1442. }
  1443.  
  1444.  
  1445.  
  1446.  
  1447.  
  1448. // TAlnShifter --------------------------------
  1449.  
  1450.  
  1451. pascal void TAlnShifter::IAlnShifter(
  1452.         TGridView        itsView; TAlnView itsAlnView, atRC: integer; seqName aName)
  1453. {
  1454.     fAlnView= itsAlnView;
  1455.     fName        = aName;
  1456.     IRCShifter(itsView->fDocument, itsView, itsAlnView, v, atRC);
  1457.     fCausesChange= TRUE; //!? fix since RCShifter thinks we make no changes
  1458.  
  1459.     fAlnView->SetEmptySelection(kHighlight); //? or move select rgn rows ?
  1460. }
  1461.  
  1462. pascal void TAlnShifter::DoShift( integer fromRC, toRC) // override 
  1463.     /*!? This won't do, 
  1464.             need to move fAlnList.contents ?? or revise TAlnIndex.GetItemText
  1465.     --  don't Swap from/to,
  1466.           need to remove seq at from, then insert seq at to.
  1467.             Need to shift a multiple selection...
  1468.     --*/
  1469. VAR
  1470.     vRect        vFrom, vTo;
  1471.     TSequence        fromSeq, toSeq;
  1472.     integer        aFromRow, aToRow, indx, saveEdit; 
  1473.     integer        saveStart, saveEnd;
  1474.     GridCell        aCell;
  1475.     
  1476.     pascal void relocate( TSequence aSeq)
  1477.     vRect        VAR vLoc; vPoint vSize,
  1478.     {
  1479.         indx= indx+1;
  1480.         if (indx >= aFromRow) && (indx <= aToRow) then {
  1481.             //! also need to shift any selection or deselect all...
  1482.           fAlnView->RowToVRect( indx, 1, vLoc);
  1483.             fAlnView->InvalidateVRect( vLoc);
  1484.             if indx == saveEdit then {
  1485.                 fAlnView->fEditRow= saveEdit;
  1486.                 fAlnView->fEditSeq->Locate( vLoc.topleft, TRUE);
  1487.                 vSize= fAlnView->fEditSeq.fSize;
  1488.                 fAlnView->fEditSeq->Resize( vSize, FALSE);  
  1489.                 }
  1490.             aCell.v= indx;
  1491.             fGrid->InvalidateCell(aCell);
  1492.             }
  1493.     }
  1494.     
  1495. {
  1496.     //- for firstSelected to lastSelected do... 
  1497.  
  1498.     fromSeq    = TSequence(fAlnView->fAlnList->At(fromRC));
  1499.     toSeq        = TSequence(fAlnView->fAlnList->At(toRC));
  1500.     if (fromSeq!=NULL) && (toSeq!=NULL) then {
  1501.         fAlnView->fAlnList->Delete(fromSeq);
  1502.         fAlnView->fAlnList->InsertBefore(toRC, fromSeq);
  1503.         if fromRC > toRC then begin 
  1504.             aFromRow= toRC; aToRow= fromRC; 
  1505.             }        else begin
  1506.             aFromRow= fromRC; aToRow= toRC; 
  1507.             }
  1508.         saveEdit= fAlnView->fEditRow;
  1509.         if saveEdit == fromRC then saveEdit= toRC
  1510.         else if fromRC > toRC then saveEdit= saveEdit + 1 
  1511.         else if fromRC < toRC then saveEdit= saveEdit - 1; 
  1512.         indx= 0;
  1513.         aCell.h= 1;
  1514.         fAlnView->fAlnList->Each(relocate);    
  1515.         fGrid->SetEmptySelection(kHighlight); //?
  1516.         }
  1517. }
  1518.  
  1519.  
  1520.  
  1521.  
  1522.  
  1523.  
  1524.  
  1525. // TAlnHIndex    -----------------
  1526.  
  1527. pascal TAlnHIndex::HandleMouseDown( VPoint theMouse, TToolboxEvent event, 
  1528.                              hysteresis: Point):Boolean; // override 
  1529. {        
  1530.     fAlnView->DeInstallEditSeq();
  1531.     //- fAlnView->SetEmptySelection(kHighlight); 
  1532.   HandleMouseDown= inherited::HandleMouseDown(theMouse,event,hysteresis);
  1533. }
  1534.  
  1535. pascal void TAlnHIndex::GetText(aCell:GridCell; Str255 VAR aString) // override 
  1536. //! don't need w/ .Draw method...
  1537. {
  1538.      aString= '';
  1539.     if aCell.h mod 10 == 0 then NumToString(aCell.h, aString);
  1540. }
  1541.  
  1542. pascal void TAlnHIndex::UpdateWidth(void)
  1543. {
  1544.     if fAlnView->fNumOfCols > fNumOfCols then 
  1545.         InsColLast( fAlnView->fNumOfCols-fNumOfCols, gAlnCharWidth)
  1546.     else if fAlnView->fNumOfCols < fNumOfCols then
  1547.         DelColLast( fNumOfCols-fAlnView->fNumOfCols);
  1548.     SetColWidth(1, fNumOfCols, gAlnCharWidth);  
  1549. }
  1550.  
  1551.  
  1552. pascal void TAlnHIndex::DrawCell(GridCell aCell, VRect aRect) // override 
  1553. //! left side of nums are badly clipped on scroll left
  1554. var  nums: str255;
  1555.          ws    : integer;
  1556.          Rect        aQDRect;
  1557. {
  1558.     VRectToRect( aRect, aQDRect);
  1559.     if ((aCell.h % 10 == 0)) {
  1560.         MoveTo(aQDRect.left, aQDRect.bottom);
  1561.         Line(0,-3);
  1562.         NumToString( aCell.h, nums);
  1563.         ws= StringWidth(nums);
  1564.         Move(-ws div 2, -1);
  1565.         DrawString(nums);
  1566.         }    else if ((aCell.h % 5 == 0)) {
  1567.         MoveTo(aQDRect.left, aQDRect.bottom);
  1568.         Line(0,-6);
  1569.         }
  1570. }
  1571.  
  1572. pascal void TAlnHIndex::Draw(VRect area) // override 
  1573. {
  1574.     inherited::Draw(area); 
  1575. }
  1576.  
  1577.  
  1578. /***********
  1579. pascal void TAlnHIndex::Draw(VRect area) // override 
  1580. var
  1581.     rect        ter ;
  1582.     integer        cat, ecat, v, ws ;
  1583.     nums    : Str255;
  1584.     pt        : point;
  1585. {
  1586.     v        = area.bottom;
  1587.     
  1588.     cat= 1;
  1589.     pt= TEGetPoint(cat, fSeq->fHTE);
  1590.     if pt.h < area.left then begin
  1591.                                                                   //! this is off by 30-40+ for 2000+ nucs
  1592.         ws= gAlnCharWidth;  
  1593.       cat= cat + (area.left - pt.h) / ws;
  1594.         pt= TEGetPoint(cat, fSeq->fHTE);
  1595.         if pt.h > area.left then
  1596.             cat= cat - (pt.h - area.left) / ws;
  1597.         end();
  1598.         
  1599.     ecat= fSeq.(*fHTE)->teLength;
  1600.  
  1601.     repeat
  1602.         pt= TEGetPoint(cat, fSeq->fHTE);
  1603.         if pt.h >= area.left then begin
  1604.             moveto(pt.h, v);
  1605.             if (cat mod 10 == 0) then begin
  1606.                 line(0,-3);
  1607.                 NumToString( cat, nums);
  1608.                 ws= StringWidth(nums);
  1609.                 move(-ws div 2,-1);
  1610.                 drawstring(nums);
  1611.                 end
  1612.             else if (cat mod 5 == 0) then
  1613.                 line(0,-8);
  1614.             end();
  1615.         cat= cat + 1;
  1616.   until (pt.h >= area.right) || (cat >= ecat);
  1617.     
  1618.     //- inherited::Draw(area); 
  1619. }
  1620. ********/        
  1621.     
  1622.         
  1623.         
  1624.         
  1625.         
  1626.         
  1627.         
  1628. // TAlnScroller ------------------------
  1629.  
  1630. pascal void TAlnScroller::Free(void) // override 
  1631. {
  1632.     fRowScroller->fMainScroller= NULL;
  1633.     fColumnScroller->fMainScroller= NULL;
  1634.     fRowScroller= NULL;
  1635.     fColumnScroller= NULL;
  1636.     inherited::Free();
  1637. }
  1638.  
  1639. pascal void TAlnScroller::SingleScroll(VPoint delta, Boolean redraw)
  1640. {
  1641.     inherited::DoScroll(delta, redraw); // scroll the main view 
  1642.     //+? fix TAlnView origin to scroller origin ???
  1643.     //+ GetAlnView->fTranslation= fTranslation;
  1644. }
  1645.  
  1646. pascal void TAlnScroller::DoScroll(VPoint delta, Boolean redraw) // override 
  1647. {
  1648.     if ((delta.v != 0) && (fRowScroller!=NULL)) fRowScroller->SingleScroll(delta, redraw);
  1649.     if ((delta.h != 0) && (fColumnScroller!=NULL)) fColumnScroller->SingleScroll(delta, redraw);
  1650.     inherited::DoScroll(delta, redraw); // scroll the main view 
  1651.     //+? fix TAlnView origin to scroller origin ???
  1652.     //+ GetAlnView->fTranslation= fTranslation;
  1653. }
  1654.  
  1655.  
  1656.  
  1657. pascal void TSideScroller::Free(void) // override 
  1658. {
  1659.     fMainScroller->fRowScroller= NULL;
  1660.     fMainScroller->fColumnScroller= NULL;
  1661.     fMainScroller= NULL;
  1662.     inherited::Free();
  1663. }
  1664.  
  1665. pascal void TSideScroller::SingleScroll(VPoint delta, Boolean redraw)
  1666. {
  1667.     inherited::DoScroll(delta, redraw); // scroll the main view 
  1668. }
  1669.  
  1670. pascal void TSideScroller::DoScroll(VPoint delta, Boolean redraw) // override 
  1671. {
  1672.     if ((delta.h != 0) && (fMainScroller!=NULL)) fMainScroller->SingleScroll(delta, redraw);
  1673.     if ((delta.v != 0) && (fMainScroller!=NULL)) fMainScroller->SingleScroll(delta, redraw);
  1674.     inherited::DoScroll(delta, redraw); // scroll the main view 
  1675. }
  1676.  
  1677.  
  1678.  
  1679. /* TAlnDlog ------------------------*/        
  1680.  
  1681. pascal void TAlnDlog::DoMouseCommand(VPoint VAR theMouse, TToolboxEvent event,
  1682.                                                Point hysteresis) // override 
  1683. {
  1684.     if (TAlnDoc(fDocument).fAlnView != NULL)
  1685.         TAlnDoc(fDocument).fAlnView->SetEmptySelection(kHighlight);
  1686.     inherited::DoMouseCommand( theMouse, event, hysteresis);
  1687. }
  1688.  
  1689. pascal void TAlnDlog::CalcMinFrame(VRect VAR minFrame) // override 
  1690. //! need to check CalcMinFrame of window 
  1691. var  aDoc: TAlnDoc;
  1692.          longint        dsize;
  1693.          VRect        listVRect;
  1694.          TScroller        aScroll;
  1695.          Vpoint        scrollSize ;
  1696. {
  1697.   inherited::CalcMinFrame(minFrame); //do horiz ?
  1698. /**********
  1699.     aScroll= NULL;
  1700.     aDoc= TAlnDoc(fDocument);
  1701.     dsize= 0;
  1702.     if ((aDoc->fSeqList != NULL)) 
  1703.         dsize= aDoc->fSeqList.fSize + 2;
  1704.     /*-- 
  1705.         fSeqListView is NULL now when called from NewTemplateWindow 
  1706.         at top of TSeqListDoc.DoMakeViews
  1707.     ---*/
  1708.     if ((aDoc->fAlnView != NULL)) {
  1709.         aDoc->fAlnView->GetFrame( listVRect);
  1710.         dsize= listVRect.top + (aDoc->fAlnView.fRowHeight * dsize);
  1711.         aScroll = TAlnScroller(aDoc->fAlnView->GetScroller(TRUE));
  1712.         scrollSize.h= 10 + aDoc->fAlnView.fNumOfCols * gAlnCharWidth;
  1713.         scrollSize.v= 10 + aDoc->fAlnView.fNumOfRows * aDoc->fAlnView->GetRowHeight(1);
  1714.         }    else {
  1715.         scrollSize.v= minFrame.bottom;
  1716.         scrollSize.h= minFrame.right;
  1717.         }
  1718.     minFrame.bottom= max(minFrame.bottom, dsize);
  1719.  
  1720. /*?! didn't need til we made view a prefwindow!!!!:    
  1721.     if ((aScroll!=NULL)) aScroll->SetScrollLimits(scrollSize, kDontRedraw); 
  1722. */
  1723. ******/
  1724. }
  1725.  
  1726.  
  1727.  
  1728.  
  1729.  
  1730. // TAlnWindow --------------------------
  1731.  
  1732. pascal void TAlnWindow::IAlnWindow(void)
  1733. {
  1734.     IPrefWindow();
  1735.     fWantSave= TRUE;
  1736. }
  1737.  
  1738. pascal void TAlnWindow::SetPrefID(void) /* override */ 
  1739. {
  1740.     gPrefWindID= kAlnDocID; gPrefWindName= 'TAlnWindow';
  1741. }
  1742.  
  1743.  
  1744.  
  1745.  
  1746.  
  1747.  
  1748.  
  1749. /* TSeqChangeCmd ------------------------*/        
  1750.  
  1751. pascal TSequence TSeqChangeCmd::ChangeToNew( oldSeq:TSequence);
  1752. //! Override this for each type of sequence changer 
  1753. {     ChangeToNew= TSequence(oldSeq->Clone());
  1754. }
  1755.  
  1756. pascal TSequence TSeqReverseCmd::ChangeToNew( oldSeq:TSequence); // override 
  1757. {      ChangeToNew= oldSeq->Reverse();
  1758. }
  1759. pascal TSequence TSeqComplementCmd::ChangeToNew( oldSeq:TSequence); // override 
  1760. {      ChangeToNew= oldSeq->Complement();
  1761. }
  1762. pascal TSequence TSeqRevComplCmd::ChangeToNew( oldSeq:TSequence); // override 
  1763. VAR  tempSeq: TSequence;
  1764. {      
  1765.         tempSeq= oldSeq->Reverse();  
  1766.         ChangeToNew= tempSeq->Complement();
  1767.         tempSeq->Free();  
  1768. }
  1769.  
  1770. pascal TSequence TSeqCompressCmd::ChangeToNew( oldSeq:TSequence); // override 
  1771. {      ChangeToNew= oldSeq->Compress();
  1772. }
  1773. pascal TSequence TSeqDna2RnaCmd::ChangeToNew( oldSeq:TSequence); // override 
  1774. {      ChangeToNew= oldSeq->Dna2Rna( TRUE);
  1775. }
  1776. pascal TSequence TSeqRna2DnaCmd::ChangeToNew( oldSeq:TSequence); // override 
  1777. {      ChangeToNew= oldSeq->Dna2Rna( FALSE);
  1778. }
  1779. pascal TSequence TSeqTranslateCmd::ChangeToNew( oldSeq:TSequence); // override 
  1780. {      ChangeToNew= oldSeq->Translate();
  1781. }
  1782. pascal TSequence TSeqLockIndelsCmd::ChangeToNew( oldSeq:TSequence); // override 
  1783. {      ChangeToNew= oldSeq->LockIndels(True);
  1784. }
  1785. pascal TSequence TSeqUnlockIndelsCmd::ChangeToNew( oldSeq:TSequence); // override 
  1786. {      ChangeToNew= oldSeq->LockIndels(False);
  1787. }
  1788.  
  1789.         
  1790. pascal void TSeqChangeCmd::ISeqChangeCmd( TAlnDoc itsAlnDoc , 
  1791.                                         TView        itsView ; TSeqList itsSeqs )
  1792. VAR start, nbases: longint;
  1793.     TCommandHandler        theContext; 
  1794.  
  1795.         pascal void CopyToNew( TSequence oldSeq)
  1796.         {
  1797.             fNewSeqs->InsertLast(this->ChangeToNew(oldSeq));
  1798.         }
  1799.  
  1800. {
  1801.     //- gApplication->CommitLastCommand(); -- Paste seqs is giving probs...
  1802.  
  1803.     fAlnView= itsAlnDoc->fAlnView;
  1804.     fAlnView->DeinstallEditSeq(); //! prevent mangle do to fBases newhandle 
  1805.     //- if (fAlnView->Focus()) ; --- what do/did we need this for ??
  1806.     fOldSeqs= NULL;
  1807.     fNewSeqs= NULL;
  1808.     // theContext:    TCommandHandler;
  1809.     theContext= itsView->GetContext(cSeqChange);
  1810.     ICommand(cSeqChange, theContext, kCanUndo, kCausesChange, theContext);
  1811.  
  1812.     if ((itsSeqs == NULL)) itsAlnDoc->GetSelection( TRUE, TRUE, itsSeqs, start, nbases);
  1813.     FailNIL( itsSeqs);
  1814.     fOldSeqs= itsSeqs;
  1815.  
  1816.     fNewSeqs= TSeqList(NewList); 
  1817.     FailNIL(fNewSeqs);
  1818.     fOldSeqs->Each( CopyToNew);
  1819. }    
  1820.  
  1821.  
  1822. pascal void TSeqChangeCmd::Free(void) // override 
  1823. {
  1824.     if ((fNewSeqs!=NULL)) {
  1825.         fNewSeqs->DeleteAll(); //forget objects -- doesn't affect objects 
  1826.         fNewSeqs->Free();             //drop list, not objects
  1827.         }
  1828.     if ((fOldSeqs!=NULL)) fOldSeqs->FreeList();     //drop all objects && list
  1829.     inherited::Free();
  1830. }
  1831.  
  1832. pascal void TSeqChangeCmd::UndoIt(void) // override 
  1833. VAR    tempList: TSeqList;
  1834. {
  1835.     tempList= fNewSeqs;
  1836.     fNewSeqs= fOldSeqs;
  1837.     fOldSeqs= tempList;
  1838.     Doit();
  1839.     fCommandDone= False; 
  1840. }
  1841.  
  1842. pascal void TSeqChangeCmd::RedoIt(void) // override 
  1843. {
  1844.     UndoIt();
  1845.     fCommandDone= True; 
  1846. }
  1847.  
  1848. pascal void TSeqChangeCmd::DoIt(void) // override 
  1849. VAR
  1850.     aFromRow, aToRow, indx, saveEdit,
  1851.     integer        i, j, nseqs, saveStart, saveEnd;
  1852.     GridCell        aCell;
  1853.     TSequence        oldSeq, newSeq;
  1854.     
  1855.     pascal void UpdateEdWinds( TSequence oldSeq, newSeq)
  1856.         pascal void checkOpenEdWinds( TWindow aWind)
  1857.         {
  1858.             if (Member(TObject(aWind), TSeqedWindow)) 
  1859.                 if (TSeqedWindow(aWind).fSequence == oldSeq) { 
  1860.                     TSeqedWindow(aWind)->ReplaceSeq(newSeq);
  1861.                     aWind->ForceRedraw();
  1862.                     }
  1863.         }
  1864.     {
  1865.         TDocument(fContext)->ForAllWindowsDo(checkOpenEdWinds);
  1866.     }
  1867.  
  1868.     pascal void relocate( TSequence aSeq)
  1869.     var     
  1870.             vRect        vLoc; vPoint vSize,
  1871.     {
  1872.         indx= indx+1;
  1873.         if (indx >= aFromRow) && (indx <= aToRow) then {
  1874.             //! also need to shift any selection or deselect all...
  1875.           fAlnView->RowToVRect( indx, 1, vLoc);
  1876.             fAlnView->InvalidateVRect( vLoc);
  1877.             if indx == saveEdit then {
  1878.                 fAlnView->fEditRow= saveEdit;
  1879.                 fAlnView->fEditSeq->Locate( vLoc.topLeft, TRUE);
  1880.                 vSize= fAlnView->fEditSeq.fSize;
  1881.                 fAlnView->fEditSeq->Resize( vSize, FALSE);  
  1882.                 }
  1883.             aCell.v= indx;
  1884.             fAlnView->InvalidateCell(aCell);
  1885.             }
  1886.     }
  1887.     
  1888. {
  1889.     if (fOldSeqs!=NULL) && (fNewSeqs!=NULL) then begin
  1890.         saveEdit= fAlnView->fEditRow;        
  1891.         aFromRow= 0;
  1892.         aToRow= 0;
  1893.         nseqs= fNewSeqs->GetSize();
  1894.         for i= 1 to nseqs do {
  1895.             newSeq= TSequence( fNewSeqs->At(i));
  1896.             oldSeq= TSequence( fOldSeqs->At(i));
  1897.             j= fAlnView->fAlnList->GetEqualItemNo( oldSeq);
  1898.             if (j>0) then {
  1899.                 fAlnView->fAlnList->InsertBefore( j, newSeq);
  1900.                 fAlnView->fAlnList->Delete( oldSeq);
  1901.                 if (aFromRow == 0) then aFromRow= j
  1902.                 else aToRow= j;
  1903.                 }    
  1904.             UpdateEdWinds( oldSeq, newSeq);
  1905.             }
  1906.         
  1907.         if ((aToRow=0)) aToRow= aFromRow;
  1908.         indx= 0;
  1909.         aCell.h= 1;
  1910.         fAlnView->fAlnList->Each(relocate);    
  1911.         //- fAlnView->SetEmptySelection(kHighlight);*/ /*?
  1912.         fCommandDone= True; 
  1913.         }
  1914. }
  1915.  
  1916. pascal void TSeqChangeCmd::Commit(void) // override 
  1917. {
  1918.     this->DoNotification();
  1919. }
  1920.  
  1921.  
  1922.  
  1923.  
  1924.  
  1925.  
  1926. /* TAlnDoc ------------------------*/        
  1927.         
  1928. CONST
  1929.     mColorButHit == 1001;
  1930.     mMonoButHit    == 1002;
  1931.     mLockButHit == kLockIconID;    
  1932.  
  1933. #pragma segment AClose
  1934.  
  1935. pascal void TAlnDoc::Close(void) /* override */ 
  1936. {
  1937.  
  1938.     /*! if !gConfiguration.hasColorQD then app bombs when this doc is closed 
  1939.             -- DUE TO RemoveSubview(fColorButton) !!!!!! */
  1940.             
  1941.         /* patches for prefwindow */        
  1942.     if ((fUseColor) && (fColorButton!=NULL)) fColorButton->fHilite= TRUE;
  1943.     //- if (fAlnWindow!=NULL) fAlnWindow->SetTitle('<<!=>> Align');  
  1944.   inherited::Close();
  1945. }
  1946.  
  1947.  
  1948. #pragma segment ARes
  1949.         
  1950. pascal void TAlnDoc::IAlnDoc( TFile itsFile)
  1951. {    
  1952.     fAlnView= NULL;
  1953.     fAlnIndex= NULL;
  1954.     fAlnHIndex= NULL;
  1955.     fUseColor= FALSE;
  1956.     fColorButton= NULL;
  1957.     fMonoButton= NULL;
  1958.     fAlnWindow= NULL;
  1959.     fSaveSelection= False;
  1960.     
  1961.     ISeqListDoc(itsFile);
  1962. }
  1963.  
  1964.  
  1965.  
  1966. pascal void TAlnDoc::DoMakeViews(Boolean forPrinting) // override 
  1967. VAR
  1968.         s            : str255;
  1969.         aView    : TAlnWindow;
  1970.         TAlnDlog        aDialogView;
  1971.         TStdPrintHandler        aHandler;
  1972.         TAlnScroller        aAlnScroller;
  1973.         TSideScroller        aSideScroller;
  1974.         vsize        : VPoint;
  1975.         hIcon        : Handle;
  1976. {
  1977. /*------- TSeqListDoc.MakeViews  -----------*/    
  1978.     fHeadline= NULL;
  1979.     fSeqListView= NULL;
  1980.     fFormatPop= NULL;
  1981.     
  1982.     fAlnWindow = TAlnWindow( gViewServer->NewTemplateWindow(kAlnDocID, this));
  1983.     FailNIL(fAlnWindow);                  
  1984.     fAlnWindow->IAlnWindow();
  1985.     aView= fAlnWindow;
  1986.     
  1987.   fFormatPop= TPopup(aView->FindSubView('pFMT'));
  1988.     if ((fFormatPop!=NULL) && (fInFormat > kUnknown)) 
  1989.         fFormatPop->SetCurrentItem(fInFormat, kDontRedraw);
  1990.     
  1991.     //get superview of window, minus scrolls, for printing
  1992.     aDialogView = TAlnDlog(aView->FindSubView('DLOG')); 
  1993.     
  1994. //!! Substitute TAlnPrintView for this handler.... !!!
  1995.     New(aHandler);
  1996.     FailNIL(aHandler);
  1997.     aHandler->IStdPrintHandler(this,                     // its document 
  1998.                               aDialogView,                    // its view 
  1999.                               !kSquareDots,            // does not have square dots 
  2000.                               kFixedSize,                 // horzontal page size is fixed 
  2001.                               !kFixedSize);            /* vertical page size is variable (could be
  2002.                                                           set to TRUE on non-style TE systems) */
  2003.  
  2004. /*------- TAlnWindow inits -----------*/    
  2005.     
  2006.     fAlnView     = TAlnView(aView->FindSubView(kAlnViewType));
  2007.     FailNIL( fAlnView);
  2008.     fAlnView->IAlnView( this, fSeqList);  
  2009.  
  2010.   fAlnIndex = TAlnIndex(aView->FindSubView('VIND'));
  2011.     FailNIL(fAlnIndex);
  2012.     fAlnIndex->fAlnList= fAlnView->fAlnList;
  2013.     fAlnIndex->fAlnView= fAlnView;
  2014.     
  2015.   fAlnHIndex = TAlnHIndex(aView->FindSubView('HIND'));
  2016.     FailNIL(fAlnHIndex);
  2017.     fAlnHIndex->fAlnView= fAlnView;
  2018.     
  2019.     //! need to have num of seqs here...
  2020.     //- fAlnIndex->DelRowLast(fAlnIndex->fNumOfRows);
  2021.     //- fAlnIndex->InsRowLast(fAlnView->fNumOfRows,fAlnView->GetRowHeight(1));
  2022.  
  2023.     // set up the aln view scroller to scroll the rows and columns too 
  2024.     aAlnScroller = TAlnScroller(fAlnView->GetScroller(TRUE));
  2025.     aSideScroller= TSideScroller(fAlnHIndex->GetScroller(TRUE));
  2026.     aAlnScroller->fColumnScroller= aSideScroller;
  2027.     aSideScroller->fMainScroller= aAlnScroller;
  2028.  
  2029.     //fix for pref saved view w/o active scrolls
  2030.     /*----
  2031.     if ((aAlnScroller!=NULL)) aAlnScroller->fScrollLimit.v= 256;  
  2032.     if ((aAlnScroller!=NULL)) aAlnScroller->fScrollLimit.h= 256;  
  2033.     ----*/
  2034.     
  2035. /*+ ?? will this help/hurt alnview overflow bug ??*/ 
  2036. /*+
  2037.     vsize.h= MaxInt; vsize.v= MaxInt;
  2038.     if ((aAlnScroller!=NULL)) aAlnScroller->SetScrollLimits(vsize, kDontRedraw);
  2039. +*/
  2040.  
  2041.     aSideScroller= TSideScroller(fAlnIndex->GetScroller(TRUE));
  2042.     aAlnScroller->fRowScroller = aSideScroller;
  2043.     aSideScroller->fMainScroller= aAlnScroller;
  2044.     
  2045.     fLockButton= TIcon(aView->FindSubView('LOCK'));
  2046.     fLockButton->fEventNumber= mLockButHit;
  2047.     
  2048.         //fix for prefwindow
  2049.     fAlnView->fLocked= TRUE; // (fLockButton->fRsrcID == kLockIconID);  
  2050.     if (gConfiguration.hasColorQD) 
  2051.         hIcon= Handle(GetCIcon( kLockIconID))
  2052.     else 
  2053.         hIcon= Handle(GetIcon( kLockIconID));
  2054.     fLockButton->SetIcon( hIcon, kDontRedraw);
  2055.  
  2056.     fColorButton= TIcon(aView->FindSubView('iCLR'));
  2057.     fColorButton->fEventNumber= mColorButHit;
  2058.     fMonoButton= TIcon(aView->FindSubView('iMNO'));
  2059.     fMonoButton->fEventNumber= mMonoButHit;
  2060.     fUseColor    = fColorButton->fHilite; //? user pref?
  2061.     fColorButton->fHilite= FALSE;
  2062.     fMonoButton->fHilite= FALSE;
  2063.     if (!gConfiguration.hasColorQD) {
  2064.             /*===    !!! this .RevmoveSubView is causing BOMBS on Close of view 
  2065.             aView->RemoveSubView(fColorButton);
  2066.             aView->RemoveSubView(fMonoButton);
  2067.             ===*/
  2068.         fColorButton->ViewEnable(FALSE, kDontRedraw);
  2069.         fColorButton->Show(FALSE, kDontRedraw);
  2070.         fMonoButton->ViewEnable(FALSE, kDontRedraw);
  2071.         fMonoButton->Show(FALSE, kDontRedraw);
  2072.         fUseColor    = FALSE;
  2073.         }
  2074.  
  2075.     ShowReverted();
  2076. }
  2077.  
  2078.  
  2079.  
  2080.  
  2081. pascal void TAlnDoc::ShowReverted(void) // override 
  2082. VAR  nc : integer;
  2083.          integer        nold, nnew;
  2084. {
  2085.     inherited::ShowReverted(); // ->> TSeqListDoc.ShowReverted !
  2086.     
  2087.     SetPortTextStyle(gAlnTextStyle);  
  2088.     gAlnCharWidth= CharWidth('G');  // must do before widths; get it here when we have a window...
  2089.     gMaxViewCellsBugFix= kMaxCoord / (gAlnCharWidth+4);
  2090.     gMaxViewCellsBugSeen= false;
  2091.     
  2092.     fAlnView->fAlnList= fSeqList;  
  2093.     nold= fAlnView->fNumOfRows;
  2094.     nnew= fSeqList->GetSize();
  2095.     fAlnView->DelRowLast( nold);
  2096.     fAlnView->InsRowLast( nnew, fAlnView->fRowHeight);
  2097.     fAlnView->UpdateAllWidths();
  2098.     
  2099.     fAlnIndex->DelRowLast(fAlnIndex->fNumOfRows);
  2100.     fAlnIndex->InsRowLast(fAlnView->fNumOfRows,fAlnView->GetRowHeight(1));
  2101.     
  2102.     /*--
  2103.     fAlnHIndex->DelColLast( fAlnHIndex->fNumOfRows);
  2104.     fAlnHIndex->InsColLast( fAlnView->fNumOfCols, gAlnCharWidth);
  2105.                 ^^^ done thru UpdateAllWidths...
  2106.     ---*/
  2107.         
  2108.     if (gMaxViewCellsBugSeen) then begin
  2109.         ParamText('a known bug prevents display of more than ~2700 bases',
  2110.                 ' All bases are there, and will be displayed in the edit window.',
  2111.                 'DisplayAlign','');    
  2112.         gApplication->ShowError( -1, msgMyError); 
  2113.         end();
  2114.         
  2115. }
  2116.  
  2117.  
  2118.  
  2119.  
  2120.  
  2121.  
  2122. pascal void PascalClose( text VAR aFile)
  2123. {
  2124.     close( aFile);
  2125. }
  2126.  
  2127.  
  2128. pascal void TAlnDoc::FirstSelection( TSequence VAR aSeq, longint VAR start, nbases)
  2129. VAR        
  2130.         atRow, right    : integer;
  2131.         GridCell        c1, c2, aCell ;
  2132. {
  2133.     c1= fAlnView->FirstSelectedCell();
  2134.     c2= fAlnView->LastSelectedCell();
  2135.     if (!EqualPt( c1, c2)) {
  2136.         right= c2.h;
  2137.         atRow= c1.v;
  2138.         aCell.h= c1.h;
  2139.         aCell.v= atRow;
  2140.         while (aCell.h<right) && !fAlnView->isCellSelected(aCell))aCell.h= aCell.h+1;
  2141.         start= aCell.h - 1;
  2142.         while (aCell.h<right) && fAlnView->isCellSelected(aCell))aCell.h= aCell.h+1;
  2143.         nbases= aCell.h - start;
  2144.         }    else {
  2145.         atRow= fAlnIndex->FirstSelectedItem();
  2146.         start= 0; 
  2147.         nbases= 0; //key for all of seq
  2148.         }
  2149.     if ((atRow < 1)) atRow= 1; //fix No selection to 1st 
  2150.     aSeq= fAlnView->SeqAt( atRow);
  2151.     if ((aSeq!=NULL)) {
  2152.         aSeq->fIndex= atRow;
  2153.         aSeq->SetSelection( start, nbases);
  2154.         }
  2155. }
  2156.  
  2157.  
  2158. pascal void TAlnDoc::GetSelection( boolean equalCount, allAtNoSelection,
  2159.                                             TSeqList        VAR aSeqList; longint VAR start, nbases)
  2160. VAR
  2161.     integer        left, right, top, bottom;
  2162.     aCell    : GridCell;
  2163.     aRow    : longint;
  2164.     aSeq    : TSequence;
  2165.     longint        start1, nbases1;
  2166.     Boolean        wantAll;
  2167.     
  2168.     pascal void AddSeqAtToList( integer aRow)
  2169.     {
  2170.         aSeq= fAlnView->SeqAt( aRow); 
  2171.         if ((aSeq!=NULL)) {
  2172.             /*--- ?? default is use all when nbases==0 !?
  2173.             if (wantAll) {
  2174.                 start1= 0;
  2175.                 nbases1= GethandleSize(aSeq->fBases);
  2176.                 }
  2177.             ---*/
  2178.             aSeq->fIndex= aRow;
  2179.             aSeq->SetSelection( start1, nbases1);
  2180.             aSeqList->InsertLast( aSeq);
  2181.             start= max(start,start1);
  2182.             if ((nBases=0)) nBases= nbases1
  2183.             else nBases= min(nBases,nbases1);
  2184.             }
  2185.     }
  2186.     
  2187. {
  2188.     aSeqList= TSeqList(NewList);
  2189.     FailNIL( aSeqList);
  2190.     
  2191.     left = fAlnView.FirstSelectedCell.h;
  2192.     right= fAlnView.LastSelectedCell.h;
  2193.     top  = fAlnView.FirstSelectedCell.v;
  2194.     bottom= fAlnView.LastSelectedCell.v;
  2195.     start= 0; start1= 0;
  2196.     nBases= 0; nBases1= 0;
  2197.     if ((left!=right) || (top!=bottom)) {
  2198.         wantAll= FALSE;
  2199.         FOR aRow= top TO bottom){
  2200.             if (equalcount) aCell.h= left else aCell.h= 1; 
  2201.             aCell.v= aRow;
  2202.             while (aCell.h<right) && !fAlnView->isCellSelected(aCell))aCell.h= aCell.h+1;
  2203.             start1= aCell.h - 1;
  2204.             if (equalCount)
  2205.                 while (aCell.h<right) && fAlnView->isCellSelected(aCell))aCell.h= aCell.h+1
  2206.             else 
  2207.                 while fAlnView->isCellSelected(aCell))aCell.h= aCell.h+1;
  2208.             nbases1= aCell.h - start1;
  2209.             AddSeqAtToList( aRow);
  2210.             }
  2211.         start = left - 1;
  2212.         nbases= right - start;  
  2213.         }    else if ((fAlnIndex.LastSelectedItem=0)) {
  2214.         wantAll= TRUE;
  2215.         if (allAtNoSelection) fAlnIndex->AllItemsDo( AddSeqAtToList);
  2216.         }    else {
  2217.         wantAll= TRUE;
  2218.         fAlnIndex->EachSelectedItemDo( AddSeqAtToList);
  2219.         }
  2220. }
  2221.             
  2222.  
  2223. pascal Integer TAlnDoc::SelectionToFile( Boolean AllatNoSelection,
  2224.             Str255        aFileName; integer seqFormat)  
  2225.             //return # written 
  2226. VAR
  2227.     longint        start, nbases;
  2228.     integer        nseqs;
  2229.     TSeqList        aSeqList;
  2230. {
  2231.     GetSelection( FALSE, allAtNoSelection, aSeqList, start, nbases);
  2232.     nseqs= aSeqList->GetSize();
  2233.     aSeqList->doWrite( aFileName, seqFormat); 
  2234.     aSeqList->Free();
  2235.     SelectionToFile= nseqs;
  2236. }
  2237.  
  2238.  
  2239.  
  2240. pascal void TAlnDoc::DoWrite(TFile aFile, Boolean makingCopy) // override 
  2241. VAR   outformat: integer;
  2242.     longint        start, nbases;
  2243.     integer        nseqs;
  2244.     TSeqList        aSeqList;
  2245.     Str63        aStr63;
  2246.     fi    : failInfo;
  2247.     
  2248.     pascal void HdlFailure(OSErr error, long message)
  2249.     {
  2250.         aSeqList= TSeqList(FreeIfObject(aSeqList));
  2251.         fSaveSelection= False;
  2252.     }
  2253.     
  2254. {
  2255.     aSeqList= NULL;
  2256.     aFile->GetName( aStr63); gOutputName= aStr63;
  2257.     if (fFormatPop == NULL) outformat= kGenBank
  2258.     else outformat= fFormatPop->GetCurrentItem(); 
  2259.     if ((fSaveSelection)) {
  2260.         fSaveSelection= False;
  2261.         CatchFailures( fi, HdlFailure);
  2262.         GetSelection( FALSE, True, aSeqList, start, nbases);
  2263.         aSeqList->doWriteRef( aFile->fDataRefNum, outformat);
  2264.         aSeqList= TSeqList(FreeIfObject( aSeqList));
  2265.         Success(fi);
  2266.         }    else {
  2267.         fSeqList->ClearSelections(); //! make sure we write all of seq from this call !?
  2268.         fSeqList->doWriteRef( aFile->fDataRefNum, outformat);
  2269.         }
  2270. }
  2271.  
  2272.  
  2273.  
  2274. pascal void TAlnDoc::DoEvent(EventNumber eventNumber, 
  2275.                                             TEventHandler        source; TEvent event) // override 
  2276. VAR
  2277.     procPtr        drawHook;
  2278.     hIcon    : Handle;
  2279. {
  2280.     switch (eventNumber) {
  2281.         case mLockButHit:
  2282.           if (fAlnView->fLocked) { 
  2283.                 fAlnView->fLocked= FALSE;
  2284.                 if (gConfiguration.hasColorQD) 
  2285.                     hIcon= Handle(GetCIcon( kUnLockIconID))
  2286.                 else 
  2287.                     hIcon= Handle(GetIcon( kUnLockIconID));
  2288.                 fLockButton->SetIcon( hIcon, kRedraw);
  2289.                 }            else {
  2290.                 fAlnView->fLocked= TRUE;
  2291.                 fAlnView->DeInstallEditSeq();
  2292.                 if (gConfiguration.hasColorQD) 
  2293.                     hIcon= Handle(GetCIcon( kLockIconID))
  2294.                 else 
  2295.                     hIcon= Handle(GetIcon( kLockIconID));
  2296.                 fLockButton->SetIcon( hIcon, kRedraw);    
  2297.                 }
  2298.             
  2299.         mColorButHit: {
  2300.              // fColorButton->HiliteState( TRUE, not fColorButton->fHilite);
  2301.           if (!fUseColor) { 
  2302.                 fUseColor= TRUE;
  2303.                 /*---
  2304.                 drawHook= &alnTEDrawHook;
  2305.                 TECustomHook(intDrawHook, drawHook, fAlnView->fEditSeq.fHTE);
  2306.                 ---*/
  2307.                 fAlnView->ForceRedraw();
  2308.                 }
  2309.             }
  2310.             
  2311.         mMonoButHit: {
  2312.              // fMonoButton->HiliteState( TRUE, not fMonoButton->fHilite);
  2313.           if (fUseColor) { 
  2314.                 fUseColor= FALSE;
  2315.                 /*---
  2316.                 drawHook= gDefTEDrawHook;
  2317.                 TECustomHook(intDrawHook, drawHook, fAlnView->fEditSeq.fHTE);
  2318.                 ---*/
  2319.                 fAlnView->ForceRedraw();
  2320.                 }
  2321.             }
  2322.                     
  2323.         otherwise
  2324.                 inherited::DoEvent( eventNumber, source, event);
  2325.         }
  2326. }
  2327.         
  2328.  
  2329.  
  2330. CONST
  2331.         kMaxOpenSeqed == 10;
  2332.  
  2333.  
  2334. pascal void TAlnDoc::AddSeqToList(TSequence item)  // override 
  2335. VAR last: integer;
  2336. {
  2337.  /*----
  2338.      inherited::AddSeqToList( item);  
  2339.     fAlnView->registerInsertLast( item);  
  2340.  ----*/
  2341.     fAlnView->addToAlnList( item);
  2342.     fAlnIndex->InsItemLast( 1);
  2343.     fAlnIndex->SelectItem( fAlnIndex->fNumOfRows, FALSE, TRUE, TRUE);
  2344.     //- fChangeCount= fChangeCount+1;
  2345.     this->Changed( 1, this);
  2346. }    
  2347.  
  2348.  
  2349.   
  2350. #pragma segment AOpen
  2351.  
  2352. pascal void TAlnDoc::OpenSeqedWindow(TSequence aSeq)
  2353. VAR
  2354.         TStdPrintHandler        aHandler;
  2355.         aSeqed    : TSeqedWindow;
  2356.         boolean        foundDoc;
  2357.         sname        : SeqName;
  2358.         
  2359.         pascal void checkOpenEdWinds( TWindow aWind)
  2360.         {
  2361.             if (Member(TObject(aWind), TSeqedWindow)) 
  2362.                 if (TSeqedWindow(aWind).fSequence == aSeq) {
  2363.                     aWind->Select(); foundDoc= TRUE;
  2364.                     }
  2365.         }
  2366. {
  2367.     foundDoc= FALSE;
  2368.     ForAllWindowsDo(checkOpenEdWinds);
  2369.     if (!foundDoc then begin
  2370.         aSeqed = TSeqedWindow(gViewServer->NewTemplateWindow(kSeqEdWindID, this));
  2371.         FailNIL(aSeqed);          
  2372.         aSeqed->ISeqedWindow(aSeq);
  2373.         sname= aSeq->fName;
  2374.         //- aSeqed->SetTitleForDoc( sname);
  2375.         aSeqed->SetTitle( concat(sname, ' Edit'));
  2376.         
  2377.         New(aHandler);  
  2378.         FailNIL(aHandler);
  2379.         aHandler->IStdPrintHandler(this,                     // its document 
  2380.                                     aSeqed->fSeqedView,                    // its view 
  2381.                                     !kSquareDots,            // does not have square dots 
  2382.                                     kFixedSize,                 // horzontal page size is fixed 
  2383.                                     !kFixedSize);            /* vertical page size is variable (could be
  2384.                                                                 set to TRUE on non-style TE systems) */
  2385.     
  2386.         aSeqed->ShowReverted(); 
  2387.         aSeqed->Open(); 
  2388.         aSeqed->Select();     
  2389.         }
  2390. }
  2391.  
  2392.  
  2393.  
  2394. pascal void TAlnDoc::OpenSeqs( boolean editOnly) 
  2395. VAR
  2396.     aCell    : GridCell;
  2397.     count    : integer;
  2398.     
  2399.     pascal void newEditWindow( integer anItem)
  2400.     TSequence        VAR aSeq;
  2401.     {
  2402.         aSeq= TSequence(this->fSeqList->At(anItem));
  2403.         if ((aSeq!=NULL) && (count<kMaxOpenSeqed)) {
  2404.             this->OpenSeqedWindow(aSeq);
  2405.             count= count+1;
  2406.             }
  2407.   }
  2408.     
  2409. {
  2410.     if ((fAlnIndex=NULL) || (fAlnIndex.firstSelectedItem == 0)) 
  2411.             //nada
  2412.             
  2413.     else if (editOnly 
  2414.         || (fAlnIndex.FirstSelectedItem == fAlnIndex->LastSelectedItem())) {
  2415.         count= 0;
  2416.         fAlnIndex->EachSelectedItemDo( newEditWindow);
  2417.         }
  2418.         
  2419. }
  2420.  
  2421.  
  2422.  
  2423.  
  2424.  
  2425. #pragma segment ARes //??
  2426.  
  2427. pascal void  TAlnDoc::DoMenuCommand(CommandNumber aCommandNumber) // override 
  2428. VAR
  2429.         aSeq        : TSequence;
  2430.         integer        menu, item, nSel;
  2431.         aName     : Str255;
  2432.         TAlnEditCommand        aAlnEditCommand ;
  2433.         TAlnPasteCommand        aAlnPasteCommand;
  2434.  
  2435.         longint        firstBase, nBases;
  2436.         TSeqList        aSeqList;
  2437.         TSeqTranslateCmd        aSeqTranslateCmd;
  2438.         TSeqReverseCmd        aSeqReverseCmd;
  2439.         TSeqRevComplCmd        aSeqRevComplCmd;
  2440.         TSeqComplementCmd        aSeqComplementCmd;
  2441.         TSeqCompressCmd        aSeqCompressCmd;
  2442.         TSeqDna2RnaCmd        aSeqDna2RnaCmd;
  2443.         TSeqRna2DnaCmd        aSeqRna2DnaCmd;
  2444.         TSeqLockIndelsCmd        aSeqLockIndelsCmd;
  2445.         TSeqUnlockIndelsCmd        aSeqUnlockIndelsCmd;
  2446.         
  2447.         
  2448.     pascal void doMakeConsensus(void)
  2449.     VAR 
  2450.             cons    : TSequence;
  2451.             TSeqList        aSeqList;
  2452.             longint        firstBase, nBases;
  2453.             arow, totalRows    : integer;
  2454.             VRect        vbounds;
  2455.     {        
  2456.         cons= fSeqList->Consensus();
  2457.         if ((cons!=NULL)) {
  2458.             aRow= fSeqList->GetIdentityItemNo( cons);
  2459.             totalRows= fSeqList->GetSize();
  2460.             fSeqList->Delete(cons);
  2461.             cons->Free();
  2462.             this->fAlnView->RowToVRect( aRow, totalRows-aRow+1, vbounds); 
  2463.             this->fAlnView->InvalidateVRect( vbounds);
  2464.             this->fAlnIndex->RowToVRect( aRow, totalRows-aRow+1, vbounds); 
  2465.             this->fAlnIndex->InvalidateVRect( vbounds);
  2466.             this->fAlnView->UpdateSize();   
  2467.             this->fAlnIndex->UpdateSize();
  2468.             }
  2469.             
  2470.         GetSelection( TRUE, TRUE, aSeqList, firstBase, nBases);
  2471.         aSeqList->MakeConsensus();
  2472.         cons= aSeqList->Consensus();
  2473.         aSeqList->Free();
  2474.         if ((cons!=NULL)) {
  2475.             AddSeqToList( cons);
  2476.             fAlnIndex->SelectItem( fSeqList.consensusRow, FALSE, TRUE, TRUE);
  2477.             fAlnIndex->ScrollSelectionIntoView(TRUE);
  2478.             }
  2479.     }
  2480.  
  2481.     
  2482.     pascal void MakeSeqPrint(Boolean doREMap)
  2483.     VAR
  2484.             TREMapDocument        aREMapDoc;
  2485.             aSeqPrDoc    : TSeqPrintDocument;
  2486.             longint        firstBase, nBases;
  2487.             aSeq        : TSequence;
  2488.     {
  2489.         FirstSelection( aSeq, firstBase, nBases);
  2490.         
  2491.         if (doREMap) {
  2492.             New(aREMapDoc);
  2493.             FailNIL(aREMapDoc);
  2494.             aREMapDoc->IREMapDocument(kPrintClipType, this, aSeq, firstBase, nbases);
  2495.             gSeqAppApplication->OpenNewDocument(aREMapDoc);  
  2496.             }        else {
  2497.             New(aSeqPrDoc);
  2498.             FailNIL(aSeqPrDoc);
  2499.             aSeqPrDoc->ISeqPrintDocument(kPrintClipType, this, aSeq, firstBase, nbases);
  2500.             gSeqAppApplication->OpenNewDocument(aSeqPrDoc);  
  2501.             }
  2502.     }
  2503.  
  2504.         
  2505.     pascal void MakeSeqSearch(integer command)
  2506.     VAR
  2507.             longint        firstBase, nBases, nList;
  2508.             aSeq        : TSequence;
  2509.             TSeqList        aSeqList;
  2510.     {        
  2511.         switch (command) {
  2512.             cGBBlast, 
  2513.             cGBFasta,
  2514.             cGeneidSearch,
  2515.             cBlocksSearch, 
  2516.             cGenmarkSearch: {
  2517.                 FirstSelection( aSeq, firstBase, nBases);
  2518.                 MailWithSeq( command, aSeq); 
  2519.                 }
  2520.                 
  2521.             cPythiaSearch,
  2522.             cGrailSearch: {
  2523.                 GetSelection( FALSE, TRUE, aSeqList, firstBase, nBases);
  2524.                 MailWithSeqList( command, aSeqList);  
  2525.                 aSeqList->Free();
  2526.                 }
  2527.             }
  2528.     }
  2529.  
  2530.     pascal void MakeAlnPrint(void)
  2531.     VAR  
  2532.             longint        start, nBases;
  2533.             aAlnPrDoc    : TAlnPrintDocument;
  2534.             aSeqList    : TSeqList;
  2535.     {
  2536.         GetSelection( TRUE, TRUE, aSeqList, start, nBases);
  2537.         if ((aSeqList.GetSize>1)) {
  2538.             New(aAlnPrDoc);
  2539.             FailNIL(aAlnPrDoc);
  2540.             aAlnPrDoc->IAlnPrintDocument(kPrintClipType, this, aSeqList, start, nBases);
  2541.             gSeqAppApplication->OpenNewDocument(aAlnPrDoc); //finish up
  2542.             //?? aSeqList->Free(); << NO, aAlnPrDoc owns this list !
  2543.             }        else {
  2544.           aSeqList->Free(); //drop only list
  2545.             MakeSeqPrint( FALSE);
  2546.             }
  2547.     }
  2548.     
  2549.     pascal void MakeDottyPlot(void)
  2550.     VAR  
  2551.             longint        start, nBases;
  2552.             aSeqList    : TSeqList;
  2553.             aDottyPlotDoc    : TDottyPlotDocument;
  2554.     {
  2555.         GetSelection( FALSE, TRUE, aSeqList, start, nBases);
  2556.         if ((aSeqList.GetSize>0)) {
  2557.             New(aDottyPlotDoc);
  2558.             FailNIL(aDottyPlotDoc);
  2559.             aDottyPlotDoc->IDottyPlotDocument(kPrintClipType, this, aSeqList, start, nBases);
  2560.             gSeqAppApplication->OpenNewDocument(aDottyPlotDoc); //finish up
  2561.             //! Don't FREE aSeqList -- DottyPlotDoc took over ownership 
  2562.             }
  2563.     }
  2564.     
  2565.     pascal void CallChildApp(theMenuName:Str255);
  2566.     VAR
  2567.         TSeqList        aSeqList;
  2568.         longint        start, nbases;
  2569.         
  2570.         pascal Boolean isTheCommand( TChildCommand aChildCommand)
  2571.         {
  2572.             if ((aChildCommand->fMenuName == theMenuName)) {
  2573.                 aChildCommand->LaunchDialog( aSeqList);
  2574.                 isTheCommand= TRUE;
  2575.                 }            else
  2576.                 isTheCommand= FALSE;
  2577.         }
  2578.         
  2579.     {
  2580.         GetSelection( TRUE, TRUE, aSeqList, start, nBases);
  2581.         if (gChildCommandList->FirstThat( isTheCommand) != NULL) ;
  2582.         aSeqList->Free();
  2583.     }
  2584.  
  2585.     pascal void    SelectSequence( integer anItem)
  2586.     {
  2587.         fAlnIndex->SelectItem( anItem, kExtend, kHighlight, kSelect);
  2588.     }
  2589.                 
  2590.     pascal void    DoSeqChangeCommand( TSeqChangeCmd aCommand)
  2591.     VAR        aSeqList: TSeqList; 
  2592.                 Longint        firstBase, nBases;
  2593.     {
  2594.         FailNIL(aCommand);
  2595.         GetSelection( TRUE, TRUE, aSeqList, firstBase, nBases);
  2596.         aCommand->ISeqChangeCmd( this, fAlnView, aSeqList); 
  2597.         PostCommand( aCommand);
  2598.     }
  2599.     
  2600.     
  2601. {
  2602.     CommandToMenuItem(aCommandNumber, menu, item);
  2603.     if (menu == mChildren) {
  2604.         switch (aCommandNumber) {
  2605.             cAddChildCmd,
  2606.             case cRemoveChildCmd:  
  2607.                 inherited::DoMenuCommand(aCommandNumber);
  2608.             Otherwise {
  2609.                         GetItem(GetMHandle(menu), item, aName);
  2610.                         CallChildApp( aName);
  2611.                         }
  2612.             }
  2613.         }        
  2614.     else CASE aCommandNumber OF
  2615.  
  2616.         cSaveSelection: {
  2617.             fSaveSelection= True;
  2618.             inherited::DoMenuCommand(cSaveCopy);
  2619.             }
  2620.             
  2621.         cSelectAll:  fAlnIndex->AllItemsDo( SelectSequence);
  2622.  
  2623.         cCut, cCopy, cClear: {
  2624.                 NEW(aAlnEditCommand);
  2625.                 FailNIL(aAlnEditCommand);
  2626.                 aAlnEditCommand->IAlnEditCommand(this, aCommandNumber);
  2627.                 PostCommand( aAlnEditCommand);
  2628.                 }
  2629.  
  2630.         case cPaste:
  2631.                 if (gClipboardMgr->fClipView->ContainsClipType(kAlnScrapType)) {
  2632.                     NEW(aAlnPasteCommand);
  2633.                     FailNIL(aAlnPasteCommand);
  2634.                     aAlnPasteCommand->IAlnPasteCommand(this);
  2635.                     PostCommand(  aAlnPasteCommand);
  2636.                     }                /* else if (gClipView->ContainsClipType('TEXT')) {
  2637.                     // convert from TEXT to sequence data...
  2638.                     }                */
  2639.                 else  
  2640.                     inherited::DoMenuCommand(aCommandNumber);
  2641.     
  2642.         
  2643.         cNewSeq        : {
  2644.                 AddNewSeqToList();
  2645.                 OpenSeqs(kEditOnly); 
  2646.                 }
  2647.                         
  2648.         cEditSeq        : OpenSeqs(kEditOnly);
  2649.  
  2650.         cConsensus    : doMakeConsensus;
  2651.  
  2652.         cTranslateSeq: {
  2653.                 New(aSeqTranslateCmd);
  2654.                 DoSeqChangeCommand( aSeqTranslateCmd);
  2655.                 }
  2656.         cReverseSeq: {
  2657.                 New(aSeqReverseCmd);
  2658.                 DoSeqChangeCommand( aSeqReverseCmd);
  2659.                 }
  2660.         cComplementSeq: {
  2661.                 New(aSeqComplementCmd);
  2662.                 DoSeqChangeCommand( aSeqComplementCmd);
  2663.                 }
  2664.         cRevComplement: {
  2665.                 New(aSeqRevComplCmd);
  2666.                 DoSeqChangeCommand( aSeqRevComplCmd);
  2667.                 }
  2668.         cCompress: {
  2669.                 New(aSeqCompressCmd);
  2670.                 DoSeqChangeCommand( aSeqCompressCmd);
  2671.                 }
  2672.         cLockIndels: {
  2673.                 New(aSeqLockIndelsCmd);
  2674.                 DoSeqChangeCommand( aSeqLockIndelsCmd);
  2675.                 }
  2676.         cUnlockIndels: {
  2677.                 New(aSeqUnlockIndelsCmd);
  2678.                 DoSeqChangeCommand( aSeqUnlockIndelsCmd);
  2679.                 }
  2680.         cDna2Rna: {
  2681.                 New(aSeqDna2RnaCmd);
  2682.                 DoSeqChangeCommand( aSeqDna2RnaCmd);
  2683.                 }
  2684.         cRna2Dna: {
  2685.                 New(aSeqRna2DnaCmd);
  2686.                 DoSeqChangeCommand( aSeqRna2DnaCmd);
  2687.                 }
  2688.         
  2689.         MakeAlnPrint        cPrettyPrint;
  2690.         cRestrictMap: MakeSeqPrint( TRUE); 
  2691.         cDottyPlot    : MakeDottyPlot;
  2692.       
  2693.         cGeneidSearch,
  2694.         cBlocksSearch,
  2695.         cGenmarkSearch,
  2696.         cGrailSearch,
  2697.         cPythiaSearch,
  2698.         cGBBlast,
  2699.         cGBSearch    :    MakeSeqSearch(aCommandNumber);
  2700.         
  2701.         default:
  2702.             inherited::DoMenuCommand(aCommandNumber);
  2703.         }
  2704. }
  2705.  
  2706.  
  2707. #pragma segment ARes  
  2708.  
  2709.  
  2710. pascal void TAlnDoc::DoSetupMenus(void) // override 
  2711. VAR 
  2712.     nsel    : integer;
  2713.     MenuHandle        childMenuHandle;
  2714.     indexSelection, haveSel    : Boolean;
  2715.     
  2716.     pascal void EnableChildMenus( TChildCommand aChildCommand)
  2717.     {
  2718.         aChildCommand->EnableMenu( childMenuHandle, nsel) ;
  2719.     }
  2720.     
  2721. {
  2722.   inherited::DoSetupMenus();    
  2723.     
  2724.     nsel= 0;
  2725.     if ((fAlnView!=NULL) && (fAlnView.FirstSelectedCell.v > 0)) 
  2726.         nsel= 1 + fAlnView.LastSelectedCell.v - fAlnView.FirstSelectedCell.v;
  2727.     indexSelection= ((fAlnIndex!=NULL) && (fAlnIndex.FirstSelectedItem>0));
  2728.     if (indexSelection && (nSel=0)) 
  2729.         nsel= 1 + fAlnIndex.LastSelectedItem - fAlnIndex->FirstSelectedItem();
  2730.     haveSel= nsel>=1;
  2731.     
  2732.     /*----
  2733.     if (indexSelection) {
  2734.         SetEditCmdName(cCut, cCutSeq);
  2735.         SetEditCmdName(cCopy, cCopySeq);
  2736.         SetEditCmdName(cClear, cClearSeq);
  2737.         }
  2738.     else if ((fAlnView->fEditRow!=0)) {
  2739.         SetEditCmdName(cCut, cCutText);
  2740.         SetEditCmdName(cCopy, cCopyText);
  2741.         SetEditCmdName(cClear, cClearText);
  2742.         }
  2743.     ----*/
  2744.     //if (indexSelection && clipHasSeqText...) CanPaste('TEXT'); 
  2745.     //if (indexSelection) */ /*!? Paste at end if no selection 
  2746.     gClipboardMgr->CanPaste(kAlnScrapType);
  2747.     
  2748.     Enable(cSaveSelection, haveSel); 
  2749.  
  2750.     Enable(cCut, indexSelection);
  2751.     Enable(cCopy, indexSelection);
  2752.     Enable(cClear, indexSelection);
  2753.     Enable(cSelectAll, TRUE);
  2754.  
  2755.     Enable( cNewSeq, TRUE);
  2756.     Enable( cEditSeq, haveSel); 
  2757.     Enable( cPrettyPrint, haveSel); 
  2758.     Enable( cDottyPlot, haveSel); 
  2759.     Enable( cConsensus, nsel>=2); 
  2760.     
  2761.     Enable( cGBSearch, gGoodMac && gTCPIsInstalled && (haveSel)); 
  2762.     Enable( cGBBlast, gGoodMac && gTCPIsInstalled && (haveSel)); 
  2763.     Enable( cGeneidSearch, gGoodMac && gTCPIsInstalled && (haveSel)); 
  2764.     Enable( cBlocksSearch, gGoodMac && gTCPIsInstalled && (haveSel)); 
  2765.     Enable( cGenmarkSearch, gGoodMac && gTCPIsInstalled && (haveSel)); 
  2766.     Enable( cGrailSearch, gGoodMac && gTCPIsInstalled && (haveSel)); 
  2767.     Enable( cPythiaSearch, gGoodMac && gTCPIsInstalled && (haveSel)); 
  2768.  
  2769.     Enable( cReverseSeq, haveSel); 
  2770.     Enable( cComplementSeq, haveSel); 
  2771.     Enable( cRevComplement, haveSel); 
  2772.     Enable( cCompress, haveSel); 
  2773.     Enable( cLockIndels, haveSel); 
  2774.     Enable( cUnlockIndels, haveSel); 
  2775.     Enable( cDna2Rna, haveSel/*&fKind=Dna or Nuc*/); 
  2776.     Enable( cRna2Dna, haveSel/*&fKind=Rna or Nuc*/); 
  2777.     Enable( cTranslateSeq, haveSel); 
  2778.     
  2779.     Enable( cRestrictMap, haveSel); 
  2780.     
  2781.     if ((gChildCommandList!=NULL)) {
  2782.         childMenuHandle = GetMHandle(mChildren);
  2783.         gChildCommandList->Each( enableChildMenus);
  2784.         }
  2785. }
  2786.  
  2787.  
  2788.  
  2789.  
  2790.  
  2791.  
  2792.  
  2793. //    TAlnEditCommand -----------------------    
  2794. #pragma segment TAlnEditCommand
  2795.  
  2796. pascal void TAlnEditCommand::IAlnEditCommand(TAlnDoc itsDocument, short itsCommand)
  2797.     FailInfo        VAR fi;
  2798.     TCommandHandler        theContext; 
  2799.  
  2800.     pascal void HdlAllocationFailure(OSErr error, long message)
  2801.     {
  2802.         Free();
  2803.     }
  2804.  
  2805. {
  2806.     fSelection= NULL;
  2807.     fOldList= NULL;
  2808.     FailNIL( itsDocument);
  2809.     // theContext:    TCommandHandler;
  2810.     theContext= itsDocument->fAlnView->GetContext(itsCommand);
  2811.     ICommand(itsCommand, theContext, kCanUndo, kCausesChange, theContext);
  2812.  
  2813.     fAlnDoc = itsDocument;
  2814.     CatchFailures(fi, HdlAllocationFailure);
  2815.     fSelection = MakeNewRgn;                     
  2816.     fOldList= TSeqList(fAlnDoc->fSeqList->Clone());
  2817.     FailNIL( fOldList);
  2818.     Success(fi);
  2819.     CopyRgn(fAlnDoc->fAlnIndex.fSelections, fSelection);
  2820.     
  2821.     fChangesClipboard = itsCommand != cClear;
  2822.     fCausesChange = itsCommand != cCopy;
  2823.     fCanUndo = itsCommand != cCopy;  //?
  2824. }
  2825.  
  2826.  
  2827. pascal void TAlnEditCommand::Free(void) // override 
  2828. {
  2829.     if ((fSelection!=NULL)) DisposeRgn(fSelection);
  2830.     fSelection = NULL;
  2831.     if ((fOldList!=NULL)) fOldList->Free();
  2832.     fOldList= NULL;
  2833.     inherited::Free();
  2834. }
  2835.  
  2836.  
  2837. pascal void TAlnEditCommand::CopySelection(void)
  2838. VAR
  2839.         TAlnDoc        clipAlnDoc;
  2840.         clipView    : TAlnView;
  2841.         
  2842.     pascal void CopyRowToClipboard(integer aRow)
  2843.     TSequence        VAR  aSeq;
  2844.     {
  2845.         aSeq = TSequence(fAlnDoc->fSeqList->SeqAt(aRow).Clone);
  2846.         clipAlnDoc->fSeqList->InsertLast( aSeq);
  2847.     }
  2848.  
  2849. {
  2850.     New(clipAlnDoc);
  2851.     FailNIL(clipAlnDoc);
  2852.     clipAlnDoc->IAlnDoc(NULL);   //< IAlnDoc creates AlnDoc->fSeqList && adds 1 blank new seq...
  2853.     clipAlnDoc->FreeData();    /* drop blank seq*/    
  2854.     clipAlnDoc->DoInitialState();  //?
  2855.     
  2856.     fAlnDoc->fAlnIndex->EachSelectedItemDo(CopyRowToClipboard); 
  2857.  
  2858.     clipView= TAlnView( gViewServer->DoCreateViews(clipAlnDoc, NULL, kAlnViewID, gZeroVPt));
  2859.     FailNIL( clipView);
  2860.  
  2861.             // from TAlnView.IAlnView....
  2862.     clipView->fAlnDoc= clipAlnDoc;
  2863.     clipView->fAlnList= clipAlnDoc->fSeqList;
  2864.     clipView->fEditSeq= NULL;
  2865.     clipView->fEditRow= 0;
  2866.     clipView->fRowheight= clipView->GetRowHeight(1); 
  2867.     clipAlnDoc->fAlnView= clipView;
  2868.  
  2869.             // from TAlnDoc.ShowReverted...
  2870.     clipView->DelRowLast( clipView->fNumOfRows);
  2871.     clipView->InsRowLast( clipAlnDoc->fSeqList->GetSize(), clipView->fRowHeight);  
  2872.     clipView->UpdateAllWidths(); 
  2873.  
  2874.     this->ClaimClipboard(clipView);  
  2875.     //- clipView->AdjustFrame(); ??
  2876. }
  2877.  
  2878.  
  2879.  
  2880. pascal void TAlnEditCommand::DeleteSelection(void)
  2881. VAR
  2882.         integer        totalRows;
  2883.         
  2884.     pascal void MarkDelete(integer aRow)
  2885.     VAR     aSeq    : TSequence;
  2886.              VRect        vbounds;
  2887.     {
  2888.         aSeq= fAlnDoc->fSeqList->SeqAt(aRow);
  2889.         if ((aSeq!=NULL)) {
  2890.             aSeq->fDeleted= TRUE;
  2891.             //- fAlnDoc->fSeqList->AtDelete(aRow);*/ /* this should be safe !!! NO !in Mapp3 (or 2)!!!...
  2892.             
  2893.             fAlnDoc->fAlnView->RowToVRect( aRow, totalRows-aRow+1, vbounds); 
  2894.             fAlnDoc->fAlnView->InvalidateVRect( vbounds);
  2895.             
  2896.             fAlnDoc->fAlnIndex->RowToVRect( aRow, totalRows-aRow+1, vbounds); 
  2897.             fAlnDoc->fAlnIndex->InvalidateVRect( vbounds);
  2898.             fAlnDoc->fAlnIndex->SelectItem( aRow, kDontExtend, kDontHighlight, !kSelect);
  2899.             }
  2900.     }
  2901.  
  2902.     pascal void ReallyDeleteMarked( TSequence aSeq)
  2903.     {
  2904.         if (aSeq->fDeleted)) fAlnDoc->fSeqList->Delete( aSeq);
  2905.     }
  2906.  
  2907. {
  2908.     totalRows= fOldList->GetSize();
  2909.     fAlnDoc->fAlnIndex->EachSelectedItemDo(MarkDelete);
  2910.     fAlnDoc->fSeqList->Each(ReallyDeleteMarked);
  2911.     fAlnDoc->fAlnView->UpdateSize();  //must do before Index.update... combine these
  2912.     fAlnDoc->fAlnIndex->UpdateSize();
  2913. }
  2914.  
  2915.  
  2916. pascal void TAlnEditCommand::RestoreSelection(void)
  2917. VAR  aRow, totalRows: integer;
  2918.     
  2919.     pascal void restoreDeletes(TSequence aSeq)
  2920.     VRect        VAR  vbounds;
  2921.     {
  2922.         aRow= aRow+1;
  2923.         if ((aSeq->fDeleted)) {  
  2924.             aSeq->fDeleted= FALSE;
  2925.             fAlnDoc->fSeqList->InsertBefore(aRow, aSeq);     
  2926.             
  2927.             fAlnDoc->fAlnView->InsRowBefore( aRow, 1, fAlnDoc->fAlnView.fRowHeight);
  2928.             /*- // insrow does this
  2929.             fAlnDoc->fAlnView->RowToVRect( aRow, totalRows-aRow+1, vbounds); 
  2930.             fAlnDoc->fAlnView->InvalidateVRect( vbounds);
  2931.             ---*/
  2932.  
  2933.             fAlnDoc->fAlnIndex->InsRowBefore( aRow, 1, fAlnDoc->fAlnView.fRowHeight);
  2934.             //- fAlnDoc->fAlnIndex->SelectItem( aRow, kExtend, kHighlight, kSelect);
  2935.             /*- // insrow does this
  2936.             fAlnDoc->fAlnIndex->RowToVRect( aRow, totalRows-aRow+1, vbounds); 
  2937.             fAlnDoc->fAlnIndex->InvalidateVRect( vbounds);
  2938.             ---*/
  2939.             }
  2940.     }
  2941.  
  2942. {
  2943.     aRow= 0;
  2944.     totalRows= fOldList->GetSize();
  2945.     fOldList->Each( restoreDeletes);
  2946.     fAlnDoc->fAlnView->UpdateSize();  //must do before Index.update... combine these
  2947.     fAlnDoc->fAlnIndex->UpdateSize();  
  2948.     ReSelect(); // == fAlnDoc->fAlnIndex->ReSelect(fSelection);
  2949. }
  2950.  
  2951.  
  2952. pascal void TAlnEditCommand::Commit(void)
  2953.     pascal void commitDeletes(TSequence aSeq)
  2954.     {
  2955.         if ((aSeq!=NULL) && (aSeq->fDeleted)) aSeq->Free();  
  2956.     }
  2957. {
  2958.     fOldList->Each( commitDeletes);
  2959.     this->DoNotification();
  2960. }
  2961.  
  2962.  
  2963. pascal void TAlnEditCommand::ReSelect(void)
  2964. {
  2965.     fAlnDoc->fAlnIndex->ReSelect(fSelection);
  2966. }
  2967.  
  2968.  
  2969. pascal void TAlnEditCommand::DoIt(void)
  2970. {
  2971.     if (fIdentifier != cClear) CopySelection;
  2972.     if (fIdentifier != cCopy) DeleteSelection;
  2973.     fCommandDone= True; 
  2974. }
  2975.  
  2976.  
  2977. pascal void TAlnEditCommand::UndoIt(void)
  2978. /* If the user has changed the selection since this command was created,
  2979.   restore it before Undoing so that the correct cells are affected. */
  2980. {
  2981.     if (fIdentifier != cCopy) {
  2982.         RestoreSelection();
  2983.         //- ReSelect;    << see RestoreSelection....
  2984.         fAlnDoc->fAlnView->ScrollSelectionIntoView(TRUE);
  2985.         fCommandDone= false; 
  2986.         }
  2987. }
  2988.  
  2989.  
  2990. pascal void TAlnEditCommand::RedoIt(void)
  2991. /* If the user has changed the selection since this command was created,
  2992.   restore it before Redoing so that the correct cells are affected. */
  2993. {
  2994.     if (fIdentifier != cCopy) {
  2995.         DeleteSelection();
  2996.         /*- ReSelect;     ! !After DELETION....*/     
  2997.         fAlnDoc->fAlnView->ScrollSelectionIntoView(TRUE);
  2998.         fCommandDone= true; 
  2999.         }
  3000. }
  3001.  
  3002.  
  3003.  
  3004.  
  3005.  
  3006.  
  3007.  
  3008.  
  3009.  
  3010.  
  3011. // TAlnPasteCommand -----------------  
  3012. #pragma segment TAlnPasteCommand
  3013.  
  3014.  
  3015. pascal void TAlnPasteCommand::IAlnPasteCommand(TAlnDoc itsDocument)
  3016. VAR     fi:            FailInfo;
  3017.         TCommandHandler        theContext; 
  3018.  
  3019.     pascal void HdlAllocationFailure(OSErr error, long message)        
  3020.     {
  3021.         Free();
  3022.     }
  3023.  
  3024.     pascal void cloneit( TSequence aSeq)
  3025.     integer        VAR  aRow;
  3026.     {
  3027.         aRow= fClipList->GetEqualItemNo(aSeq);
  3028.         aSeq= TSequence(aSeq->Clone());
  3029.         fClipList->AtPut( aRow, aSeq);
  3030.     }
  3031.  
  3032. {
  3033.     // theContext:    TCommandHandler;
  3034.     theContext= itsDocument->fAlnView->GetContext(cPaste);
  3035.     ICommand(cPaste, theContext, kCanUndo, kCausesChange, theContext);
  3036.  
  3037.     fAlnDoc = itsDocument;
  3038.     CatchFailures(fi, HdlAllocationFailure);
  3039.     fSelection = MakeNewRgn;                            // copy the current selection region 
  3040.     Success(fi);
  3041.     CopyRgn(fAlnDoc->fAlnIndex.fSelections, fSelection);
  3042.     //- fClipDocument= TAlnView(gClipView).fAlnDoc;
  3043.         /*^^ used cloned clip list of seqs only, private store so other commands don't
  3044.             mysteriously mangle our command before commit...
  3045.             --- still mangling before commit -- do away w/ clone cliplist,
  3046.             && clone on doit, free on undo...
  3047.         */
  3048.     fClipList= TSeqList(TAlnView(gClipboardMgr->fClipView).fAlnList->Clone());
  3049.     fClipList->Each( cloneit);
  3050.  
  3051.     fInsRow= fAlnDoc->fAlnIndex->LastSelectedItem();
  3052.     if (fInsRow=0) fInsRow= fAlnDoc->fSeqList->GetSize();
  3053.     
  3054.     fReplacedSeqs= TSeqList(NewList);
  3055.     FailNIL(fReplacedSeqs);
  3056. }
  3057.  
  3058.  
  3059. pascal void TAlnPasteCommand::Free(void) // override 
  3060. {
  3061.     if (fSelection != NULL) DisposeRgn(fSelection);
  3062.     fSelection = NULL;
  3063.     TObject(fClipList) = FreeListIfObject(fClipList); //New since cloned clip list
  3064.     TObject(fReplacedSeqs) = FreeListIfObject(fReplacedSeqs);
  3065.     inherited::Free();
  3066. }
  3067.  
  3068.  
  3069. pascal void TAlnPasteCommand::DoIt(void)
  3070. VAR  aRow, totalRows: integer;
  3071.         
  3072.     pascal void InsertMarker( TSequence aSeq)
  3073.     VRect        VAR   vbounds;
  3074.     {
  3075.         aRow= aRow+1;
  3076.         // mark here, fDeleted, then clone in .Commit method
  3077.         aSeq= TSequence(aSeq->Clone()); //!NEW: prevent mangle by other cmds
  3078.         aSeq->fDeleted= TRUE;  //< this is mark that we Inserted it (not deleted)
  3079.  
  3080.         fAlnDoc->fSeqList->InsertBefore( aRow, aSeq);
  3081.         
  3082.         fAlnDoc->fAlnView->InsRowBefore( aRow, 1, fAlnDoc->fAlnView.fRowHeight);
  3083.         /*-- // insrow does this
  3084.         fAlnDoc->fAlnView->RowToVRect( aRow, totalRows-aRow+1, vbounds); 
  3085.         fAlnDoc->fAlnView->InvalidateVRect( vbounds);
  3086.         ---*/
  3087.  
  3088.         fAlnDoc->fAlnIndex->InsRowBefore( aRow, 1, fAlnDoc->fAlnView.fRowHeight);
  3089.         /*-- // insrow does this
  3090.         fAlnDoc->fAlnIndex->RowToVRect( aRow, totalRows-aRow+1, vbounds); 
  3091.         fAlnDoc->fAlnIndex->InvalidateVRect( vbounds);
  3092.         ---*/
  3093.     }
  3094.  
  3095. {        
  3096.     aRow= fInsRow;
  3097.     /*---
  3098.     totalRows= fAlnDoc->fSeqList.GetSize + fClipDocument->fSeqList->GetSize();
  3099.     fClipDocument->fSeqList->Each(InsertMarker);
  3100.     ---*/
  3101.     totalRows= fAlnDoc->fSeqList.GetSize + fClipList->GetSize();
  3102.     fClipList->Each(InsertMarker);
  3103.     fAlnDoc->fAlnView->UpdateAllWidths();
  3104.     fAlnDoc->fAlnView->UpdateSize();  //must do before Index.update... combine these
  3105.     fAlnDoc->fAlnIndex->UpdateSize();  
  3106.     fCommandDone= True; 
  3107. } 
  3108.  
  3109.  
  3110. pascal void TAlnPasteCommand::UndoIt(void)
  3111. VAR
  3112.         integer        totalRows;
  3113.         
  3114.     pascal void DeleteIfMarked(TSequence aSeq)
  3115.     VAR     vbounds: VRect;
  3116.              integer        aRow;
  3117.     {
  3118.         if ((aSeq!=NULL) && (aSeq->fDeleted)) {
  3119.             aSeq->fDeleted= FALSE;
  3120.             aRow= fAlnDoc->fSeqList->GetEqualItemNo( aSeq);
  3121.             fAlnDoc->fSeqList->AtDelete(aRow); // is this safe? -- we are in SeqList.Each...
  3122.             aSeq->Free(); //!NEW: prevent mangled command 
  3123.             
  3124.             fAlnDoc->fAlnView->RowToVRect( aRow, totalRows-aRow+1, vbounds); 
  3125.             fAlnDoc->fAlnView->InvalidateVRect( vbounds);
  3126.             
  3127.             fAlnDoc->fAlnIndex->RowToVRect( aRow, totalRows-aRow+1, vbounds); 
  3128.             fAlnDoc->fAlnIndex->InvalidateVRect( vbounds);
  3129.             fAlnDoc->fAlnIndex->SelectItem( aRow, kDontExtend, kDontHighlight, !kSelect);
  3130.             }
  3131.     }
  3132.  
  3133. {
  3134.     totalRows= fAlnDoc->fSeqList->GetSize();
  3135.     fAlnDoc->fSeqList->Each( DeleteIfMarked);
  3136.     fAlnDoc->fAlnView->UpdateAllWidths();
  3137.     fAlnDoc->fAlnView->UpdateSize();  //must do before Index.update... combine these
  3138.     fAlnDoc->fAlnIndex->UpdateSize();
  3139.     fCommandDone= false; 
  3140. }
  3141.  
  3142.  
  3143. pascal void TAlnPasteCommand::RedoIt(void)
  3144. {
  3145.     DoIt();
  3146.     fCommandDone= True; 
  3147. }
  3148.  
  3149. pascal void TAlnPasteCommand::Commit(void) // override 
  3150.  
  3151.     pascal void commitInserts(TSequence aSeq)
  3152.     integer        VAR  aRow;
  3153.     {
  3154.         if ((aSeq->fDeleted)) {
  3155.             aSeq->fDeleted= FALSE;
  3156.             /*---   !NEW: no more: too much hassle
  3157.             aRow= fAlnDoc->fSeqList->GetEqualItemNo( aSeq);
  3158.             aSeq= TSequence(aSeq->Clone());
  3159.             fAlnDoc->fSeqList->AtPut( aRow, aSeq);
  3160.             ---*/
  3161.             }
  3162.     }
  3163. {
  3164.     fAlnDoc->fSeqList->Each( commitInserts);
  3165.     this->DoNotification();
  3166. }
  3167.  
  3168. pascal void TAlnPasteCommand::UpdateViews(void)
  3169. {
  3170.  
  3171. }
  3172.  
  3173.